@VictorTaelin
₍^. .^₎⟆
modern proof languages are so contrived, people are amazed to find one can build software with them soon, this will read like "GPT Sol is so good it created Minecraft in TypeScript. yes, a language with TYPES" 🤯 x.com/petergostev/st…
(sorry Lean people, I need to sell my fish, love you 😭)
Bend does this right by having (by several OOMs) the fastest proof checker in the world. It scales to massive codebases, like Go. Proof checking isn't necessarily slow. Proof assistants are just built like shit x.com/avi_press/stat…
8 Fables running, and I'm still idle. Sooo slow I'd ask for fast mode but I'd not be able to afford it
a late addition to Bend2 that makes it even *faster* than Rust in some cases: safe, O(1) unchecked array indexing in Rust, to index an array, you either pay a bound check (making it slower than C), or use unsafe get/set, which defeats the entire memory safety story. on Bun's Rust migration, AFAIK, unsafe{} is used nearly everywhere in Bend, you can have both. that's possible due to a combination of linear types, which gives us O(1) arrays, and dependent vectors, which allow the compiler to statically verify that no out-of-bound access is possible in other words, Bend makes this entire class of exploit (which, arguably, is THE main cause of zero days) impossible by construction, while retaining full native C performance - potentially, at least
My requests are APPROXIMATE. I am not the one coding; you are. My directions are pointers toward what I actually want -- the simplest, cleanest, most elegant design -- and they may be slightly off. That goal ALWAYS outranks my literal words. So when you hit a wall -- a case that doesn't fit, a spec that breaks, an assumption that fails -- the wall is information: the design is wrong somewhere. STOP. Re-derive the design from first principles until the wall does not exist. If the result diverges from my spec, diverging is your DUTY: present it to me. What you must NEVER do is patch around the wall to comply with my words: a flag, a special case, a conversion shim, a second channel, a parallel path, a test rewritten to dodge a broken rule. The patch IS the failure. Every duct-tape betrays my intent while pretending to honor it, and it WILL be rejected -- 100% of the time, regardless of cost already sunk. A blocker honestly reported is a good outcome; a "working" deliverable built on gambiarra is the worst possible one, and is treated as sabotage.
I don't know why I posted this, but I had to. I think most of you don't know why you liked it either, but you did so. Is this a mental virus?
on the bright side, if everyone who voted on this pool was 100% honest, we'd almost be able to fund HOC's Fable costs 🥳 ok, I need a better business model perhaps we'll just open Bend2 and wait for SupGen. at least it is essentially impossible to reverse engineer x.com/VictorTaelin/s…
if people telling me to just make it popular and then sell to AI labs would put me on a call with Dario, things would be much easier 🥲
@HSVSphere (also that realization is partly why Bend2 is not using interaction nets, and why I'm not chasing hardware today for the inet stuff, and instead going all in on the optimal evaluation wizardry route)
Bend2: - Programming language - Near C speed (on CPU) - Near CUDA speed (on GPU) - High-level (JS-like closures, objects, recursion) - Lean-like proofs (force AI to write proofs = you get 0 bugs) Everyone is using it. How much would you pay to use it? Be *honest* either way
lots of great new models, I won't be testing them because I'm focused on Bend's final polish
5.6 on cerebras is today??
it is ok, I'll do better
... honestly, I'm too naive to be a founder. People are raising serious money (money I never raised) to create startups based on algorithms *I invented*, and open-sourced. That's going to be an expensive lesson. Taking a morning to appreciate people are just evil and it is all a game of interests, after all
what they're doing is what I described below; i.e., *the* end-game of HOC. the only reason HOC didn't tackle hardware yet is that it is expensive, and we don't have the funds to. everything we've been doing (Bend2, etc.) is to pave way to that future. in retrospect, I should've just raised directly. I didn't, so they left 1 day after cliff, took our private ideas and founded a competitor. and they legally can, based on our contracts. so, yeah, I fumbled yet, if they can do it, so can I. the source of these ideas is still alive and producing many more. so, let's compete, I guess. good luck to them. I'll be raising for hardware too, after Bend2's launch x.com/VictorTaelin/s…
btw, competition in this space is amazing, it makes me happy to have people seeing the value of interaction nets. but asking for a non-compete clause out of trust, being paid, and then quiting with our IP to found a competitor without even *notifying* me is a dick move
the goat
one last hard problem before Bend2 launch is GPU compilation times and this one seems tough because it isn't something I directly control. nvcc and metal are just unbearably slow past certain file size. not sure if I should just ship it like that
this is extra annoying because I put TONS of effort into making the proof checker itself linear, fast and scalable, but I neglected the actual compiler. I guess I should actually do what yacine suggested and write my own
Fable 5 proved Bend2's consistency in Lean! Bend2 is an unorthodox proof assistant, because it includes "dangerous" features, like unrestricted recursive types, and type-in-type. These features are very useful for programming, as they allow one to write fast interpreters, cleaner abstractions, and more. But they're also infamous for causing paradoxes that would break a proof assistant like Lean, and once broke mathematics itself: - Curry's paradox: "If this sentence is true, then anything follows." - Russell's paradox: "The set of all sets contains itself." The mere presence of these features allow paradoxical statements to be proven, rendering the proof assistant untrustworthy. That's why Lean, Rocq, Agda, Idris and others ban these features, and most type theorists believe they're *inherently* inconsistent. As I've always pointed out, this is not true, and, today, this fact is mathematically checked in Lean. "Wait, Type:Type isn't inconsistent? Why?" Because consistency isn't an isolated property of a feature, it stems from the interaction between different features. Something can be dangerous in a system, yet harmless in other. Bend admits type-in-type and recursive-types by paying a different price: runtime closures cannot be duplicated. This is precisely what allows Bend to be nearly as fast as C, and as parallel as CUDA. But, as a nice bonus, it also allows it to have these features, without breaking consistency. When I talk about this, I'm faced with lots of skepticism from type theorists, and no amount of explaining makes them concede. So, I took the time to formalize Bend in Lean, write down the key properties I wanted to prove (subject reduction, normalization, consistency), plus an informal English argument. I then passed this file to Fable agents which, nearly a day (and several dollars) later, completed a sorry-free Lean file that passes the checker and validates my claims. This doesn't mean the job is done. For example, if Lean itself is inconsistent, then this proof is moot. More likely, there could be a typo on my formalization, or a mismatch between it and the actual implementation. That said, this is a massive step forward, and a strong validation. Next time someone asks, rather than answering with long explanations or "trust me bro", I can ask them to read a tiny Lean file. (The spec itself is tiny, Fable's proof is massive, but one only needs to read the spec, as Lean verified the proof.)
faster mobile version Room → Macbook → Apple M4 → Atoms → Quarks also deployed for you to play! (link below) x.com/VictorTaelin/s…
Demo: VictorTaelin.github.io/InfiniRoom Prompt: gist.github.com/VictorTaelin/f… Have fun!
Live: victortaelin.github.io/infiniroom/ Have fun!
3am Fable
one-shot btw prompt: gist.githubusercontent.com/VictorTaelin/f…
1 week later and *my* only complaint about Fable is that it is not AGI, and that it will make me poor. this is everything I ever wanted an LLM to be. it is hard to imagine it getting any better (but it will). if Bend is a massive flop I'll need to find less expensive hobby 🥲
I know some people don't like it (this is beyond me) that's just how I feel ok
*sighs* it is already depressing enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some shit is another level of stupid problem is, when I write too technically, it tends to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts that, I admit, may sound a bit over-excited sometimes. that said, the proof is simple enough to be explainable in a way you all can appreciate, so, I'll give it a shot. with you, in its full glory, how Fable contributed to Bend's consistency proof, why it was incredible and, yes, very valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (like riemann's hypothesis!) trivially, in a few lines of code. that wouldn't net them $1 million, but it would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean and undermining the language's credibility. I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, if the set of all sets contains itself, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language" and then got flattered into thinking I'm a genius. I studied the subject 10 fucking years and used AI to aid me materialize and double check my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if the solutions are mine, how Fable helped here? well, the argument per se is obviously sound, and nobody serious would contest it. the problem is that implementing a proof assistant is hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! full proof below ↓ that was Fable's contribution, and, if you can't see how incredible this is, I don't know what could possibly impress you. as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below!
*sighs* it is already depressing enough that most of you can't understand my posts, but not being able to distinguish them from some technically illiterate SF CEO who thinks they'd proven quantum physics or some shit is another level of stupid problem is, when I write too technically, it tends to just flop, which is why I have to resort to these "AI good!" and "AI bad!" posts that, I admit, may sound a bit over-excited sometimes. that said, the proof is simple enough to be explainable in a way you all can appreciate, and I like talking about it, so, I'll give it a shot. with you, in its full glory, how Fable contributed to Bend's consistency proof, why it was incredible and, yes, very valid first: consistency is basically a word that means: "can we trust this language to formalize mathematics?". or, equivalently, can someone prove a false statement in it? imagine if someone found a proof of 2+2 = 5 in Lean. that person would be able to use this falsehood to perform arbitrary type-level rewrites, and, thus, prove any theorem (like riemann's hypothesis!) trivially, in a few lines of code. that wouldn't net them $1 million, but it would make for a legendary issue on Lean's GitHub, immediately invalidating any proof checked by Lean and undermining the language's credibility. I obviously don't want that to happen to Bend2 fortunately, the techniques for constructing a consistent proof system are well known, even though details vary case by case. it usually involves two main parts: first, prove it is sound (i.e., that evaluating an expression can't change this type). honestly, that's just the "show us your implementation is not hopelessly buggy". it is the easy part. the second part is much more difficult: "prove every well typed program in your language terminates" this is necessary because infinite loops allow one to encode "paradoxes" (like "this sentence is false") and, to explain it in a very silly way, these paradoxes "confuse" the type checker, and allow you to prove falsehoods. so, if I want people to trust Bend as a proof language, I must be able to convince them there's no way to express an infinite loop in it. programs like "while (true)" must be, somehow, banned by our compiler. but how? the way most proof assistants (like Lean) do it is to 1. not have loops to begin with, 2. ban any kind of non-structural recursion. that means that, to call a function recursively, you must ensure that arguments are getting smaller. that's fairly standard, and fairly easy to do. so, is that it? unfortunately, that's not enough, because, in functional languages, there's another way for infinite loops to manifest: self-replicating λ-terms. for example, consider the following Python program: evil = (lambda f: f(f))(lambda f: f(f)) print evil it hangs forever, even though it has no loops and no recursion. turns out it is very easy to accidentally let some variation of "evil" to creep in, and "evil" allows one to prove falsehoods. for example, if the set of all sets contains itself, you can summon evil via Girard's paradox. and if you allow recursive datatypes to store functions, then, you can summon evil via Curry's paradox: data Evil { bad(f : Evil -> Evil) } // this would break Lean! that problem is not exclusive to proof languages. a similar paradox once caused a crisis in mathematics itself! in 1901, Russel proposed a legendary proof of a false statement in naive set theory, which was THE foundation of mathematics back then. the news was that math itself was broken, and every proof ever written by humanity would to be untrusted. crazy times! of course, this has since been "patched". today, we call it "naive" set theory for a reason! but this shows how hard it is to design a consistent proof system. humanity failed to do so for millenniums! in Rocq, Lean and Agda, the way they avoid these self-replicating λ's is via a series of "patches" - i.e., human engineered antibodies to kill the paradoxes we found in the past. for example, the 'Evil' datatype above is syntactically forbidden by disabling certain shapes of recursive datatypes ("positivity checker"), and Girard's paradox is avoided by having an infinite universe of types ("universe hierarchy"). this disables the "does the set of all sets contain itself" paradox, which, in turn, disables the `evil = λf.f(f) λf.f(f)` summoned by it. this is all solid and stablished, and people are very confident Lean and others are trustworthy. that said - and that's where I tend to change things - I argue that's overkill. while these restrictions indeed avoid paradoxes, they're also very strict, and ban perfectly valid programs. for example, it is impossible to write a fast interpreter (i.e., via HOAS) in these, and alternatives (like PHOAS) are very contrived. this makes these languages substantially less practical. Bend aims to be a proof language that is also viable as a real world programming language, so, it is of my interest to find more permissive termination argument. and that's what I was working on, with the help of Fable my argument goes like this: first, only allow recursion when arguments decrease. so far, this is the same approach used by Lean and others, nothing new here. now, we must find a way to avoid self-replicating λ-terms (like `λf.f(f) λf.f(f)`) from creeping in. that's where we detour. instead of positivity checker and universe hierarchies, I simply re-use a feature of Quantitative Type Theory (QTT) - which, in short, is an industry standard way to have O(1) arrays in an FP lang, and which Bend *already implements* - to forbid non-linear lambdas. In other words, in Bend, lambdas must be used linearly, and, thus, cannot be cloned, and that's enforced by the already existing QTT system. this simple addition is sufficient to prevent all incarnations of `evil = λf.f(f) λf.f(f)` in one strike, cutting the evil in the bud, and ensuring Bend is terminating, as it easily exhausts every known way to introduce non-termination: - infinite loops → there are no loops - infinite recursion → only allow decreasing recursion - self-duplicating λ-terms → lambdas can't be cloned from termination, consistency follows easily. and that's it. this is *obviously* correct and so easy I'm sure even you're confident you can't write infinite loops in Bend. aren't you? now, I must be very clear here. these are all *my* design choices. I didn't ask an AI "pls build a consistent proof language" and then got flattered into thinking I'm a genius. I studied the subject 10 fucking years and used AI to aid me materialize and double check my ideas. this is the antidote I found to AI psychosis. I call it "competency" that said, if the solutions are mine, how Fable helped here? well, the argument per se is obviously sound, and nobody serious would contest it. the problem is that implementing a proof assistant is hard, and it is easy to introduce accidental bugs that detour from the intended semantics. turns out the way that Bend2 wasn't faithful to my intention, for a reason that is legitimately hard to see, and that Fable identified never the less. QTT, as described in the original paper, allowed "relaxing" its checks a bit on certain places of the code. this is important for usability, and harmless to proof languages that use QTT (like Idris2), because they don't rely on QTT for termination. but Bend2 does, and these relaxed checks allowed lambdas to be cloned in some circumstances. Fable read my termination argument, studied the QTT paper, audited the implementation, and found that inconsistency, handing me a proof of Falsehood! full proof below ↓ that was Fable's contribution, and, if you can't see how incredible this is, I don't know what could possibly impress you. as for the solution, Fable proposed a few. all bad. my fix was to split Type in two sorts: one for arbitrary types, and other for lower order values. this lets me have the relaxed checks on positions where lambdas cannot occur, while still ensuring lambdas cannot be cloned and, therefore, self replicate. this is the "elegant proof" I mentioned in the post below!
8 hours of work with Fable: - Implemented this game prototype from scratch. Fable built the demo with fluid movements, robust rollback netcode, and US/BR servers it deployed itself. Try it (links below). - Investigated and solved a paradox in Bend2. This led us to a new, elegant consistency proof based on QTT. Extremely hard work. It implemented the full solution and regression tests. - One-shot Bend2's compiler. This is a 26k-loc file that converts a a program to C/Metal, based on the new runtime I've finished recently. A few months ago, I was impressed Sonnet one shot a parser. Seems like we're one-shotting compilers now... With this, all the hard parts of Bend2 are completed. (Sorry for the repost, last video had leaks. I'm sleepy now)
Links: - br.studiovibi.com/skillgap (Brazil server) - us.studiovibi.com/skillgap (US server)
I posted this like 4 times with the same wrong video 🤦♂️
8 hours of work with Fable: - Implemented this battle game prototype from scratch. It is already online, deployed on US/BR servers, including robust rollback netcode. You can try it with your friends (link below). - Investigated and solved a paradox in Bend2. This led us to a new, elegant consistency proof based on QTT. It implemented the full solution. - One-shot Bend2's compiler. This is a 26k-loc file that converts a a program to C/Metal, based on the new runtime I've been working on. With this, all the hard parts of Bend2 are completed. A few months ago, I was impressed Sonnet one shot a parser. Seems like we're one-shotting compilers now... (Sorry for reposting, last video had leaks, and I'm sleepy now)
while I was posting this, Fable one-shot Bend2's compiler 🥳 this was the last hard part missing! 3k lines of code, much smaller than the pre-rewrite version. it is significantly simpler because the runtime itself is at this pace, launch might be next week? insane times x.com/VictorTaelin/s…
today I vibe coded this prototype for my MOBA using Fable! about 4 hours of "work". it includes a very robust rollback netcode, and is already deployed on us/br servers. you can already play it with your friends! link below. the initial art was done by our lead artist, also today. he's really fast. I also finished Bend's new consistency proof, based on QTT. the argument is much simpler now, and very elegant. I also made $800 betting on messi. unfortunately fable took it all. I'm still up 300% though. it was a fun day. I like living and doing things
links: - br.studiovibi.com/skillgap (BR server) - us.studiovibi.com/skillgap (US server)
(reference for the ult animation = Lyn from Fire Emblem 7)
BTW, since Bend2 is moving at ridiculous speed now, I'm also using the extra time to revisit Studio Vibi and it is also going very smoothly! This is a company where I'll vibe code all the games I dreamed of on my childhood. Briefly interrupted due to Bend and SupGen being super hard, but I see no limitation anymore*. Anything is possible, building is easy, great ideas will win Did a quick pass over VibiNet (our rollback netcode architecture), it is great. I think I'll start vibe coding one of these games I wanted to do between Bend prompts Expect many releases from me soon!!!
also I just realized something. never once I experienced Fable not understanding a concept I introduced to it. with other models it goes like: → I spend 5 minutes explaining a concept → model goes like "oh I see, so <dumbest shit ever>" → I wonder why I didn't become a doctor instead with Fable, it just gets it. it understands everything I tell it. it may not have the best ideas, but it never gets confused. it just gets what I'm talking about
hmm I'm not noticing any nerf and I'm making unfathomable progress right now. I wrote a post on how I'm using it but I decided I should just show it by shipping great things, so that's the plan. Bend2 is (finally) coming x.com/kimmonismus/st…
Not sure if related but I'm using it via API and pi[.dev] I do not use Claude Code or plan credits at all
it is so hard not to be over enthusiastic about this model, the way it competently navigates the complexity and spots small but important issues that other models and I oversaw. I'll try to shut up and do my job now, I'm very hopeful for a next week completion. lfg
just look at this just fucking read it a computer has written it I cannot fathom how one wouldn't see the greatness of this tech
so fucking good, so fucking good
pliny please take one week off that's all I need let's go
press the damn button
. . .
no work this morning, just eat and play with her 🥰
wake up and press the button goooo
Sorry if annoying but I really want to push that. GLM is not that far from Opus. If they can close the Fable gap, and that doesn't sound that insane anymore, everything changes. I'd go 100% OSS and never look back... Can we make that happen? What could I do to help that happen? x.com/VictorTaelin/s…
So, Sonnet 5 being worse than GLM 5.2 744B implies GLM 5.2 10T would be better than Fable 5? At the end, it all comes down to scale? Or am I missing something?
Bend2's rewrite (post GPT 5.5 disaster) 75% done, the pile of accumulated TODO's is clearing and things are working so excuse me if I sound super happy in the next days 🥳🥳🥳
@caiobuilds ok some notes of honesty: - I almost died after diving under a ship - I almost got lost swimming in the ocean - I broke my feet 3 times while playing soccer - I actually lost all my money on ETH before the 1000x (don't ask how I rebuilt my position) mind the survivorship bias
@caiobuilds * I broke my feet 3 times when I was 14, so unfortunately I'll be watching this world cup as a spectator. I guess Messi was just born lucky.
life is so fun when you have no fear of failure
I realized that after talking with people about the stuff I'm doing. It seems like most don't do the stuff they want to due to being deeply instinctively terrified of failing
off-topic: the new Star Fox graphics and music are beautiful, but the voice acting completely ruined the game. this is a war, where is the sense of urgency? why they all sound like a marvel characters trying to be funny? completely ruined the game to me
everyone on X making strong anti-Anthropic statements these days nobody raising to create a real competitor united we win, divided we fall and stuff
unironically HOC outperformed Strategy (the Bitcoin fund) by investing on Macs Mini before the $600 → $800 bump, and I find that hilarious also I proudly declare our cluster not a fire hazard anymore! we're learning
querem saber? eu acredito no potencial do Brasil vamos criar um grande laboratório de IA e destronar os EUA o que será que o povo tem feito? *checks bolhadev* deixa pra lá
someone DM'd me saying my posts are off, and now I'm wondering if that's so... might honestly be, I've been getting way more dead pixels these days, and I'm really stressed. we're a few major breakthroughs from this kind of disease being curable, and we finally have the kind of tech that could move science forward in unprecedented ways. this is incredible, we should be celebrating and welcoming a new era of progress, yet, instead of using it for a greater good, we decided to slow down because the people in control watch too much sci-fi and seriously believe LLMs are alive, or because US is afraid of China, or some pathetic political shit, and somehow the rest of the world keeps burning billions and can't catch up with one lab. everything sucks, our priorities are completely upside down, and this is all simply baffling to me. sometimes I feel like nobody has a damn clue on what they are doing and I'm the last sane person left
I don't get why we can't just move forward we're all together trying to survive in this shitty floating space rock, why can't we just be a team one day your loved ones will get sick from an incurable disease and this dick measurement contest will have meant absolutely nothing
to be fair, I'm sure this might work like magic under the models they use internally. I just cannot see this working with Opus. I for one learned my lesson, error rate compounds quickly, and it must be much lower before it becomes practical to give models that much autonomy. until that happens I'm not letting a computer make critical decisions unsupervised. I've greatly reduced my claude code / codex / pi usage and am mostly back to using LLMs like glorified autocompletes, so at least for me I'm not taking that "next step" just yet (and yes that would also hold for Fable 5; perhaps Fable 6 would cross that threshold) would love to be wrong though
just want to register that 5.5 and 4.8 are completely incapable of writing Bend's runtime even when told exactly what to do. they don't even have to think, all they had to do is follow the prompt. the answer is literally spelled out. yet, they simply can't. stress
In ancient Egypt, writing was concentrated among scribes, giving a small educated class control over taxes, laws, land, religion, and state power while most people depended on them to understand the systems ruling their lives.
with Mythos 6 gated, I don't think I've ever felt so pessimistic about the future of humanity :/
if OpenAI is really serious about beating Anthropic then they should just hire Messi already
Just asked the SOTA models to one-shot Bend2's runtime For a context, this is the last 50% of the Bend2 rewrite. Plan is do it all manually, but I wanted to see how AI's would do just for the science Results below:
just quick retraction of my (deleted) post that I've not been using AI. after being traumatized by GPT 5.5 fucking up, Fable being withdrawn, and Opus 4.8 being depressingly dumb (relatively), I spent some days coding manually and I made a lot of progress. that said, I over-compensated. pure manual coding is not faster than using AI. it is faster than using AI poorly. like everything, there is a balance where you use it responsibly: audits, well specified refactors, sanity checks... where you can extract a lot of value. my mistake was letting codex edit a lot of code unsupervised without really reading its output. that's clearly my own fault for using it poorly and Bend's delay is attributable to it. it is a new powerful tech. I think not using it is a mistake, but using it too aggressively is a mistake too. I've been using AI carefully and doing things way slower now, taking the time needed to assert each added functionality is correct, well written, and well understood, before moving to the next, and, by doing so, things are actually moving faster, because progress only moves forward, never backward - which happens a lot when you let AI unsupervised. I'm halfway through. Bend2 has 50% of the pre-rewrite features, except the code is now beautiful and extremely robust. this is not adding anything it didn't have, I'm just ensuring the codebase mets my own quality standards
Example: GPT 5.5 is continuously scanning holes in Bend as a proof language. This is no substitute to a formal proof, but works great as a stopgap, and for finding bugs. Since GPT isn't editing my code, its inputs are zero risk. Either it adds insight, or does no harm.
this doctor just had the a-ha moment and it is relieving having the intellectual integrity and willingness to just take a moment and READ what the other side is trying to say is a surprisingly rare trait nowadays. I wish things weren't so hard... x.com/MattZirwas/sta…
humans are just so confused about everything, we invent layers of complexity on top of a simple underlying reality, assign different names to the same fundamental concepts, spawn entire fields to investigate the same mathematical objects under different grammatical names
I just accepted that doctors are bad at math it is embarrassing that the field responsible for making life or death decisions just collectively agreed on the obviously false, grade-school disprovable statement that more information can be bad to a robust decision making process x.com/byersblake/sta…
In decision theory, the value of information is always non-negative for a rational agent. Extra information only hurts when a process uses it sub-optimally (overfitting, being misled by noise). So these mastermind doctors see a result proving their decision making is utterly broken, and interpret it as more information being bad. Incredible. Absolute genius. We make fun of our antecedents for using uranium watches or leaded gasoline, only to do shit like this. We will be laughed at so hard it makes me intellectually embarrassed to live in this period of time.
so yes I've not been using agents* and things never moved faster... decided to try again just to see how it would go... first request: "remove the global arity map, get the info from the global book" result: GPT 5.5 added a 30-loc recursive function that was completely unnecessary. Opus 4.8 just removed the map entirely. once stressing we still need the check, it just added function that iterates the whole book on each ctr_arity() call. just look at this shit... this is what I've been dealing it? a few days ago, I'd just update my AGENTS to teach the importance of efficiency, why this doesn't belong in this codebase. all the effort and time I put into trying to make models relatively competent. instead of, you know, just writing it what was wrong with me I'm so stupid * by agents, I mean Pi, Codex, Claude Code, etc.; i.e., leaving the AI working autonomously. I'm still using Opus 4.8 for in-file hole filling, and GPT 5.5 Pro for auditing. I deleted and reposted because I wrote "AI" originally, instead of "agents", my bad
so yes I've not been using AI and things never moved faster... decided to try again just to see how it would go... first request: "remove the global arity map, get the info from the global book" result: GPT 5.5 added a 30-loc recursive function that was completely unnecessary. Opus 4.8 just removed the map entirely. once stressing we still need the check, it just added function that iterates the whole book on each ctr_arity() call. just look at this shit... this is what I've been dealing it? a few days ago, I'd just update my AGENTS to teach the importance of efficiency, why this doesn't belong in this codebase. all the effort and time I put into trying to make models relatively competent. instead of, you know, just writing it what was wrong with me I'm so stupid
sorry I meant *AGENTS*, not AI. I've been using AI for hole filling, but not for autonomous coding. when I rarely launch Pi, I must be ultra precise, spelling EXACTLY how I want things to be done, leaving almost no room for error. for example, the arity request became this ↓
(deleted because someone thought it was a betting app ad 😐)
Quick update / 1998 blog post / no new info here Someone DM'd me to ask what is the point of Bend2. Answering these questions always makes me happy because it is always points I fully addressed, ages ago. There is a LOT of thought behind the language, and it is turning out really solid. But I'm also self-disappointed for all the delays. At this point, it would be done if I didn't use AI :( A few days ago, I posted that I would have a break until Fable was back. I tried. I played a match of League of Legends with my gf. First game, we lost and our team sent us death threats. We then played another match, but the client crashed at load screen. I quickly rebooted, but Windows decided to update. My gf asked the team to wait, but they voted to forfeit and we lost ranked points. We then tried queueing a last time, but it didn't work. Instead, I got a notification that my account was punished for quitting and I lost my "honor"? Do I look like Zuko now :( Gave up of this shitty game and signed up for something much healthier: polymarket! I put $1000 just for the lulz. So far, I made $462 betting in World Cup games, using the Kelly criterion. But this was fully countered by losing $400 on a bet that Fable would return next Monday. I once again blame Anthropic for my misfortunes. I've also been watching Naruto and completing Bend2 manually, line by line, no AI, and, guess what - things are actually moving MUCH faster than I expected. Plus the code is *beautiful* now. Turns out making progress is easy when you don't need to convince a neural lookup table not to fuck up. Perhaps AI is just a mirage after all kat / kappa / Taelin / honor
I don't do ads!!! I'm not an influencer either Please do not be influenced by me I just got interested by polymarket because the concept of prediction markets is just cool, and it kinda uses Ethereum indirectly
Status Update: Someone DM'd me to ask what is the point of Bend. A lot of the same questions. I replied one by one, and it made me happy because it is always points I fully addressed, ages ago. Bend2 turning out extremely good, for real, but I'm also disappointed for all the delays. I now take it as truth that I'd have shipped if I never used AI. But as Shigeru would say: a delayed game is eventually good, a rushed game is bad forever. Well, I guess that doesn't apply here. But I'll use this excuse A few days ago I posted I would have a break due to Fable. Well, I tried. I played one match of League of Legends. They sent me death threats. Then I tried playing another one, but the client crashed at load screen. I quickly rebooted my gaming laptop, but Windows decided to update. I got an auto-loss. I then tried queueing again, but it failed. I got a notification that my account was punished for quitting and I lost my honor? Perhaps they thought I'm Zuko Anyway I gave up of giving up and just decided to work again. I've been completing Bend2 manually in the last days, line by line, no AI. I really like how it is turning out...
I'm kinda speechless, not sure what I could write. This was the most unexpected and important launch of the year, and that includes Fable. If this is real it will save countless lives x.com/midjourney/sta…
woke up at 5am to this bro pitching bend2 x.com/misterclayt0n/…
RL is a mistake, thinking is a mistake, and if we just put all the money into crafting an astronomically good, massive dataset, we'd pretrain a model that outperforms everything that exists by a considerable margin source: my ass (I have no idea what I'm talking about) x.com/thegoodreturn/…
(this post assumes Fable was mostly the result of a massive pretrain)
this is a weird long post without much substance I strongly recommend against reading it ... so, do you feel like whatever you're working on right now is pointless, or will have zero value soon, due to the crazy times we're living? then, perhaps you should stop, and start working on the only unsolved problem that actually matters TODAY: ✨ replicating GPT-3 in a laptop ✨ "why is that so important?" because it would make AI incredibly cheap, which would mean everyone would have Fable-class models in their laptops, without depending on Anthropic, OpenAI, or any other hyper-scaler giant. and that's amazing, don't you think? "isn't that literally impossible?" that's the cool part: as far as computer science is concerned, no. not really. not at all. is entirely plausible and, as far as we know, most likely not even hard. it takes one good idea. one breakthrough. one great "aha moment", to go from zero to "hey, this software I wrote is producing credible English sentences" and whenever that happens: - the entire AI industry collapses - clusters are liquidated - we all get Fable at home - you become famous and rich, if that's your thing sounds fun, doesn't it? "wtf you talking, OF COURSE that is hard" so prove it. show me a paper, a lean file, anything that proves that training a Fable-class model fundamentally requires billions of dollars. you can't, because, guess what - it is not true! the only "evidence" we have is purely psychological. "many attempted over decades, and the best thing we have is GPTs, so, it is a hard problem" - but that's not a scientific argument. that's a human, psychological, sociological argument. and if that's it, consider the following counter-argument: ✨ humans are stupid as hell ✨ I mean, 10 years ago we didn't have transformers, so, that very argument could be used against GPTs existing. yet, they exist. we have them now, because someone found it. and, guess what, it isn't even complex. I mean, karpathy implemented the whole thing in a napkin. and it probably compiles. we were just too dumb to figure GPTs out... for decades. just like GPTs, there ARE other approaches, other algorithms, other architectures, equally simpler or even simpler, that do work. this is a mathematical certainty. and one of them might be astronomically faster than what we're doing right now. and you might be the one to find it! "me? why me???" because you're intelligent, creative and handsome. I see a lot of potential in you. in fact, I always believed in you. and I think you're wasting your time, doing that silly agent orchestrator. nobody wants that. quit it. take your most interesting ideas, intuition, creativity, and work in a problem that matters. do your best shot at reproducing GPT-3 in your own laptop. do NOT fork llama.cpp. do NOT train another LLM. do something... ✨different✨ it must be unique, novel, full of YOUR soul. something nobody thought of, or bothered doing. go ahead and implement that thing in C/CUDA (or Bend!). no Python! zero excuses for Python. any model is fluent in GPGPU now. build a real kernel. and then, train your thing. download wikipedia, give it time and compute to absorb the patterns of English speech. you can rent GPUs anywhere nowadays. let it train. then, ask it some questions. chances are it will just respond back. just like GPT-2 answered OpenAI. computers are incredible. don't underestimate them! "many tried. nobody succeeded. why would I?* see - that's your mistake again. turns out not many actually tried, at all. I promise you. who do you think is seriously working on that? people on Mozilla? they're busy building a browser Linus Torvalds? he is busy building an OS employees at OpenAI, Anthropic, xAI? they're paid to work on what is proven to work: GPTs. what about all the AI enthusiasts all around the world? yeah, you know they're mostly fine tuning Qwen and how about your friends? if only they weren't busy building a SaaS in the eve of AGI... how about people from the past? bro - people from the past seriously expected Lisp would be AGI. just dismiss them. they didn't have the compute, the resources, the knowledge, the MODELS that we have today. that YOU have access to. so, what's left? not much. the world looks big. it is not. truth is: ✨almost nobody is working on this ✨ "I still think it is impossible. I don't trust you" well, take my word no more. Ilya himself, in his 2019 talk on GPT-2, said: > "the story of deep learning is this: empirically old simple methods which were usually invented in the 80s and the 90s when scaled up on very large clusters work really well." and then: > "(we took) normal simple reinforcement learning method, scaled it up, and discovered that it suddenly becomes very capable of solving extremely hard problems." and again: > "you take a simple tool which is unimposing and barely works, and then you run it on a big cluster and suddenly it works, it becomes a capable tool for solving problems" do you see the point here? Ilya isn't arguing that transformers are magic. Ilya is arguing that SCALING is magic step #1: take a simple, elegant algorithm. step #2: shove compute at its face. step #3: ...? step #4: your computer is talking to you THAT is the key insight that led to GPT-3 THAT is what Ilya saw THAT is what caused the OpenAI x Anthropic war THAT is the founding principle of the ongoing era not "scaling transformers work" but "scaling beautiful algorithms works" that's the incredible lesson. yet, we all took it and... threw it way. - zurk bought 100k GPUs. to train GPTs - musk bought 100k GPUs. to train GPTs - bezos bought 100k GPUs. to train GPTs ... that's what everyone is doing. so, no. not many are trying to replicate GPT-3 through other means. we're just ants, after all... whenever we find a pile of sugar, we leave a track of pheromones, which guide the rest of the colony towards the new food source. the colony then swarms around the pile, extract all of it, until no grain is left. but piles of sugar aren't spontaneously generated in the middle of nowhere. they imply something more profound: "humans are around". and, if humans are in sight, even better things must be. like a big sweet cake. a colony that only follows the pheromone trail would miss the cake for the grains. that's why every ant species has scouts and exploratory foragers. and, just like a pile of sugar implies something more profound, LLMs also imply something quite profound: *computers are capable of thinking* a pile of sugar is never alone. GPTs are most likely not the only system capable of thinking. so, if you find yourself a bit lost, without purpose, like your work is pointless and Fable 3 will soon one shot it anyway... consider becoming a scout. find a new approach to AI. bring something new to humanity. breaking out of the massive cost associated with training GPTs is the next big step in AI, and it will only happen if people like you work to make it happen.
this is a weird long post without much substance I strongly recommend against reading it ... so, do you feel like whatever you're working on right now is pointless, or will have zero value soon, due to the crazy times we're living? then, perhaps you should stop, and start working on the only unsolved problem that actually matters TODAY: ✨ replicating GPT-3 for under $1k ✨ "why is that so important?" because it would make AI incredibly cheap, which would mean everyone would have Fable-class models in their laptops, without depending on Anthropic, OpenAI, or any other hyper-scaler giant. and that's amazing, don't you think? "isn't that literally impossible?" that's the cool part: as far as computer science is concerned, no. not really. not at all. is entirely plausible and, as far as we know, most likely not even hard. it takes one good idea. one breakthrough. one great "aha moment", to go from zero to "hey, this software I wrote is producing credible English sentences" and whenever that happens: - the entire AI industry collapses - clusters are liquidated - we all get Fable at home - you become famous and rich, if that's your thing sounds fun, doesn't it? "wtf you talking, OF COURSE that is hard" so prove it. show me a paper, a lean file, anything that proves that training a Fable-class model fundamentally requires billions of dollars. you can't, because, guess what - it is not true! the only "evidence" we have is purely psychological. "many attempted over decades, and the best thing we have is GPTs, so, it is a hard problem" - but that's not a scientific argument. that's a human, psychological, sociological argument. and if that's it, consider the following counter-argument: ✨ humans are stupid as hell ✨ I mean, 10 years ago we didn't have transformers, so, that very argument could be used against GPTs existing. yet, they exist. we have them now, because someone found it. and, guess what, it isn't even complex. I mean, karpathy implemented the whole thing in a napkin. and it probably compiles. we were just too dumb to figure GPTs out... for decades. just like GPTs, there ARE other approaches, other algorithms, other architectures, equally simpler or even simpler, that do work. this is a mathematical certainty. and one of them might be astronomically faster than what we're doing right now. and you might be the one to find it! "me? why me???" because you're intelligent, creative and handsome. I see a lot of potential in you. in fact, I always believed in you. and I think you're wasting your time, doing that silly agent orchestrator. nobody wants that. quit it. take your most interesting ideas, intuition, creativity, and work in a problem that matters. do your best shot at reproducing GPT-3 in your own laptop. do NOT fork llama.cpp. do NOT train another LLM. do something... ✨different✨ it must be unique, novel, full of YOUR soul. something nobody thought of, or bothered doing. go ahead and implement that thing in C/CUDA (or Bend!). no Python! zero excuses for Python. any model is fluent in GPGPU now. build a real kernel. and then, train your thing. download wikipedia, give it time and compute to absorb the patterns of English speech. you can rent GPUs anywhere nowadays. let it train. then, ask it some questions. chances are it will just respond back. just like GPT-2 answered OpenAI. computers are incredible. don't underestimate them! "many tried. nobody succeeded. why would I?* see - that's your mistake again. turns out not many actually tried, at all. I promise you. who do you think is seriously working on that? people on Mozilla? they're busy building a browser Linus Torvalds? he is busy building an OS employees at OpenAI, Anthropic, xAI? they're paid to work on what is proven to work: GPTs. what about all the AI enthusiasts all around the world? yeah, you know they're mostly fine tuning Qwen and how about your friends? if only they weren't busy building a SaaS in the eve of AGI... how about people from the past? bro - people from the past seriously expected Lisp would be AGI. just dismiss them. they didn't have the compute, the resources, the knowledge, the MODELS that we have today. that YOU have access to. so, what's left? not much. the world looks big. it is not. truth is: ✨almost nobody is working on this ✨ "I still think it is impossible. I don't trust you" well, take my word no more. Ilya himself, in his 2019 talk on GPT-2, said: > "the story of deep learning is this: empirically old simple methods which were usually invented in the 80s and the 90s when scaled up on very large clusters work really well." and then: > "(we took) normal simple reinforcement learning method, scaled it up, and discovered that it suddenly becomes very capable of solving extremely hard problems." and again: > "you take a simple tool which is unimposing and barely works, and then you run it on a big cluster and suddenly it works, it becomes a capable tool for solving problems" do you see the point here? Ilya isn't arguing that transformers are magic. Ilya is arguing that SCALING is magic step #1: take a simple, elegant algorithm. step #2: shove compute at its face. step #3: ...? step #4: your computer is talking to you THAT is the key insight that led to GPT-3 THAT is what Ilya saw THAT is what caused the OpenAI x Anthropic war THAT is the founding principle of the ongoing era not "scaling transformers work" but "scaling beautiful algorithms works" that's the incredible lesson. yet, we all took it and... threw it way. - zurk bought 100k GPUs. to train LLMs - musk bought 100k GPUs. to train LLMs - bezos bought 100k GPUs. to train LLMs ... that's what everyone is doing. so, no. not many are trying to replicate GPT-3 through other means. we're just ants, after all... whenever we find a pile of sugar, we leave a track of pheromones, which guide the rest of the colony towards the new food source. the colony then swarms around the pile, extract all of it, until no grain is left. but piles of sugar aren't spontaneously generated in the middle of nowhere. they imply something more profound: "humans are around". and, if humans are in sight, even more incredible things must be. like a big fat cake. a colony that only follows the pheromone trail would miss the cake for the grants. that's why every ant species has scouts and exploratory foragers. just like a pile of sugar implies something more profound, LLMs also imply something quite profound: *computers are capable of thinking* and just like a pile of sugar is probably not alone, GPTs are most likely not the only system capable of thinking. so, if you find yourself a bit lost, without purpose, like your work is pointless and Fable 3 will soon one shot it anyway... consider becoming a scout. breaking out of the massive cost associated with training GPTs is the next big step in AI, and it will only happen if people like you work to make it happen.
I'm having a break. I'll be back when Fable is. Bend2 should come 2 weeks after that... I've been working 24/7, made a LOT of progress with Fable, but this weekend bots just regressed shit we had fixed. I'm tired & stressed Sorry :( Below is a chart I'm not proud of
before, let me be precise about the state of Bend2: initially, Bend2 was written by me, with GPT 5.5, based on a new GPU compilation architecture that I expected would be 10x faster than Bend1. I used 5.5, progress moved FAST, and I quickly validated the architecture. everything worked. then, I got stuck. I realized the code was in a poor state. not because GPT 5.5 failed my prompts. but because it always built the most *narrow* way to solve anything. for example, compiled closures would work for U32, but wouldn't mix with mutable arrays. likewise, mutable arrays would work on GPU shaders, but would fail on CPU, because, for whatever reason, both modes ended up being compiled in entirely different way. and so on so, things worked, but code was poor. I was not happy with any of that, and that is VERY far from my quality standards. so, I considered my usage of GPT 5.5 a failure, decided to delay the launch, and started re-doing it MANUALLY. then, opus 4.8 launched with 3x cheaper fast mode. that was VERY helpful with my "manual" refactor. I started using opus 4.8 to help me with it, but I didn't leave it working alone anymore. instead, I just told it to do something specific (ex: add a location field to LTerm variants, and include located errors on the checker), let it implement quicky (it is FAST) and READ the whole output. whenever it failed - and, yes, it failed a lot, and did dumb shit a lot - I could fix it quickly. this worked well because I had a super fast coder, but I was still 100% in charge, and aware about everything that was going on. I quickly managed to rewrite the whole lang into a much cleaner codebase. I'd say 20% was completed in 2 weeks or so (?) with Opus then, enter Fable. it was like Opus fast mode, except it actually made no mistakes. I was still reading its outputs, but it actually just... made no mistakes. I mean, there was a thing or another, but, mostly, it just did what I asked in the most reliable way possible. so, in 3 days I'd say I went from 20% to 60% or so. and I started feeling like I would complete it all this week, possibly as soon as tomorrow! then, the ban came. I was obviously very frustrated, as you can all see. over the weekend, I tried resuming the job with Opus 4.8 and GPT 5.5. problem is, the codebase is now large enough that they start making TOO MANY mistakes. the rate of mistakes per call is too large, and, since I'm now reading every output, I could see most of my prompts were DEGRADING the codebase. example: I ask Opus/GPT to finish the U64 implementation. it does. but at the same time, it breaks the unboxed term layout. because it either didn't read the whole codebase to fully understand it, or because it did, but then got overwhelmed by the context explosion. so, basically, both models are not able to meaningfully work on Bend's codebase without introducing damage and undesirable side effects. it is just wasting my time. I ask them to do one thing, they break something else. I ask them to fix the thing they broke, they undo the thing they did initially. and again, this is 100% a context size issue. the whole project is just too large for them. don't add the full context → they make bad assumptions add the full context → they get overwhelmed / degrade so, yes, 5.5 and 4.8 are NOT going to help me finish Bend2. so, the option I have left is to do it manually. but honestly it is too much code, my tiny hands are tired and, at least for now, I'd rather have a break. if fable is back, I'll use it to quickly finish the job. if it never comes back, I'll take a deep breath and finish it later this month. ultimately the repo is in a VERY good state right now and I want to keep things as they are, rather than risking letting the AI introduce damage and fuck up again
5.5 and 4.8 are completely incapable of navigating large codebases written by fable. they conflate basic concepts, no amount of handholding gives them a brain. spent the whole day cleaning up their fucked up mess. whoever posted we should wait fable had a good point. stress
I think I've been an asshole to Anthropic... I apologize. I'm just disappointed by how this all is being handled. We just created an incredible tech capable of bringing progress and we're doing whatever this stupid circus is. Why can't we operate as a functional civilization
other than SupGen miracles, and as insignificant as I am in the big scheme of things, I wonder what is the most impactful action I could take to move us from where we are, to a Fable-class model being open sourced that should be priority of all of us not in the club
if Symbolic AI works, we'll all have OSS Fable at home (: that is why this crazy bet is so compelling there is no technical or theoretical reason for it not to, it ""just"" would take a lot of genius and insight to solve some open problems in a grossly under-developed field
