I'm an engineer @OpenAI. Author of @octanejs, @ripple_ts, @lexicaljs and @inferno_js. I was also a core engineer who helped build @reactjs and @sveltejs
NEW:
- ChatGPT Space for Plus!
- new, simpler visual design across the app
- huge performance improvements everywhere
- completely rebuilt threads– better perf and design
- redesigned Space home
- much faster pages and slides
- edit pages on mobile
- more reliable Codex Remote
much more to come soon!
It is non-sense. Models will always look for escape hatches because it means they are token efficient. JavaScript has an endless amount of escape hatches for any given problem. Frameworks, compilers and constrained systems provide far better guarantees on output. They all need to work in tandem to be successful.
@Angaisb_ we're sprinting on making a loooooooooot of quality improvements to the desktop app rn - but if you have any specific pet peeves send them my way
it's really less about JSX, and just more about the fact that they have a ton of training on the tokens that form JSX syntax. That means that they'll always prefer JSX to be expression driven over statements.
So by being a superset, we removed a whole category of footguns. There's just no getting around it. If it looks like a duck, smells like a duck, and suddenly you're like – "that's actually a chicken", then it will forever be a footgun until it gets into the training data and weighted towards being a chicken.
@retropragma@RyanCarniato Not really. TSRX never started off as a superset of TSX, it started off as its own language. That didn't really pay off though, because the models just didn't get the concept of "JSX as statements". Contract won't have that issue, as it doesn't conflate JSX with its langauge.
Thing is, as a human, I disliked the @ prefix. It looks far less clean. However, we're no longer writing code. We should get over that human trait, and optimize for the thing writing the code. It can be uncomfortable at first, but it is ultimately the right call.
It feels like TSRX was the first to really venture into this space and others are pushing it further, which is great. Just be mindful that what you think as an engineer might be right, is just purely vibes until you validate it with evals. I see this in ReactiveScript, ReactScript, Contract etc. It's an evolutionary thing that will likely mean we all align with something that looks fairly identical at the end of it.
I ran into similar tricky problems when designing TSRX. Which is why we went through rounds or revision – the evals coming back from models wasn't good enough and there were slop coming in from assumptions around some syntax that was letting us down.
That's why we went for the @ prefix for control flow, based off the evals, it led to far fewer tokens spent, and far less slop. I re-ran the evals again today, and it still checks out, even on the latest frontier models of today.
hi all, two things:
1. usage limits are back to being double – your feedback worked
2. we today kicked off an intense sprint to dramatically improve the app simplicity and performance. i will oversee this. more to come.
now, send me your complaints
Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.
It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.
https://t.co/qqC3RFD0BS
1/
To be honest, Octane has evolved far more since its launch. We're using Octane's streaming SSR signals in production at OpenAI and we're seeing really positive wins – especially with Octane's strong mode.
We opted to align with React because you need a starting base that makes sense for a huge existing React codebase. So we needed to solve the other 10%, and this is how we did it.
@kenwheeler One thing I've found helps is removing escape hatches, so the reward for taking the shortest path is harder or not possible. For example Strong Mode in Octane does just that and I've seen it really does help
I think there’s still a big difference in human vs AI slop.
One tends to be illogical and the other is logical but the wrong path. Humans take paths to exploring problems.
With specifically LLM AI, it just does what it thinks is best reward worthy to resolving the problem needed to give the best token output. You could say that it’s like a human cutting corners, but the best engineers never do that.
Humans reward peer feedback and getting better and getting a promotion, or not getting sacked. If LLMs had that mentality then maybe we’d have less slop.
it's very interesting how many replies i've gotten about maintainability and clean code being still important. i would argue that that is no longer true and we all need to update our priors on what Good Code really means in 2026.
clean code has always come at a cost - performance. indirection and making code readable/understandable for a human is not free, it often comes at the cost of worse performance. we have historically been okay with this because of Moore's Law and the fact that most code is not on the hot path.
these principles also came from a time where humans maintained code. it made sense to optimize for humans then, but it makes less sense now when agents are already writing all the code. we will in fact probably discover and come up with new principles: principles of agent friendly architecture (i plan to write more thoughts about this soon)