Gregor Mitscha-Baude

@github JS and TS are the same language though, you need to combine them

It's true: TypeScript surpassed Python and JavaScript to become the most-used language on GitHub. 📈

@natolambert SI-adjacent benchmark where Claude leads: x.com/i/status/20284…

@natolambert I think it can be framed as social intelligence, and IMO there should be more benchmarks for that. Claude probably has a huge lead

We need to transition the conversation from Claude being the first company to go all in on code to how they clearly were way ahead on general agent behavior. Could be a bigger deal, as I suspect all the labs will “solve” coding. Not sure what the agent secret sauce is.

@AnthropicAI Amazing, huge respect

A statement from Anthropic CEO, Dario Amodei, on our discussions with the Department of War. anthropic.com/news/statement…

Huge respect to @AnthropicAI for standing up to this

@jxnlco please please please train it to have better social intelligence. sure it's good at coding but it's such a pain to just talk to. it'll constantly misunderstand you or make weird alien judgments. claude opus is light-years better at "getting humans".

Ok but like what can we be doing better on codex.

@cryptodavidw I think all of those prompt "hacking" ideas are outdated and/or so random that I wouldn't even bother trying. Just focus on giving good context

We don't understand much about improving prompts in some weird and fundamental ways. For example, should you start your prompt with "you are a Rust engineer" or "you are the world's best Rust engineer"? Should you tell the agent to role play as the world's best Rust engineer or should you tell it to *be* a Rust engineer? It's not clear. Some people will use prompts like "You've read all the Rust books that exist, ..." does it work better? I've heard people saying you should insult your agent, and it will perform better, but is it really better to start your prompts with "you MOTHER FUCKER you better do good to me this time"? I do it sometimes, feels good, but does it really work? I've also heard things like "if you don't write good Rust code, 10 puppies will die". If I were to choose, I would say this is the most likely to provide good results, although the agent most often don't believe you. So yeah, we have no idea.

peak 2026 (from @TechCrunch)

@__tosh + personality + memory

agent: loop + llm + tools claw: agent + cron + auth + messaging gui ?

now that code is cheap, doesn't someone want to build a good, open Linux-based OS? 😄

@banteg it also works in pi/openclaw. it's just not authorized

still works in takopi. how does it do it?! bunny keeps getting away with it (by actually studying how things work)

@koeppelmann both :) via github.com/badlogic/pi-mo…

Claude or Codex?

@thsottiaux how to make a more high agency/human-spirit version of codex that's as pleasant to use as a co-worker as claude

Codex team is fairly distributed, but most of the team is gathering in person over next 48 hours to take a step back and align on what’s next this year. What should we discuss?

@kimmonismus ich muss sagen ich fand das interview nicht painful. richtig gut gelungen eigentlich, speziell peter's antworten. armin wolf ist bekannt für scharfen interview stil, hier war er verhältnismäßig freundlich :D und die fragen sollen ja auch jene des publikums repräsentieren

As most of you know, I'm from Germany, so I was able to watch the entire interview with Peter Steinberger on "Zeit im Bild." It was incredibly painful. Not because of Peter's answer, but because the journalist's questions-typically German-Austrian - almost exclusively revolved around whether we should be afraid of AI, whether data privacy is being respected, what dangers OpenClaw poses, and so on. The hottest topic in the world was talked down. Instead of sparking curiosity and enthusiasm among viewers, the program ultimately only stirred up more anxiety and resentment. A damning indictment of Europe.

@Thom_Wolf who else is excited about applying this insight to JS/TS? x.com/mitschabaude/s…

Shifting structures in a software world dominated by AI. Some first-order reflections (TL;DR at the end): Reducing software supply chains, the return of software monoliths – When rewriting code and understanding large foreign codebases becomes cheap, the incentive to rely on deep dependency trees collapses. Writing from scratch ¹ or extracting the relevant parts from another library is far easier when you can simply ask a code agent to handle it, rather than spending countless nights diving into an unfamiliar codebase. The reasons to reduce dependencies are compelling: a smaller attack surface for supply chain threats, smaller packaged software, improved performance, and faster boot times. By leveraging the tireless stamina of LLMs, the dream of coding an entire app from bare-metal considerations all the way up is becoming realistic. End of the Lindy effect – The Lindy effect holds that things which have been around for a long time are there for good reason and will likely continue to persist. It's related to Chesterton's fence: before removing something, you should first understand why it exists, which means removal always carries a cost. But in a world where software can be developed from first principles and understood by a tireless agent, this logic weakens. Older codebases can be explored at will; long-standing software can be replaced with far less friction. A codebase can be fully rewritten in a new language. ² Legacy software can be carefully studied and updated in situations where humans would have given up long ago. The catch: unknown unknowns remain unknown. The true extent of AI's impact will hinge on whether complete coverage of testing, edge cases, and formal verification is achievable. In an AI-dominated world, formal verification isn't optional—it's essential. The case for strongly typed languages – Historically, programming language adoption has been driven largely by human psychology and social dynamics. A language's success depended on a mix of factors: individual considerations like being easy to learn and simple to write correctly; community effects like how active and welcoming a community was, which in turn shaped how fast its ecosystem would grow; and fundamental properties like provable correctness, formal verification, and striking the right balance between dynamic and static checks—between the freedom to write anything and the discipline of guarding against edge cases and attacks. As the human factor diminishes, these dynamics will shift. Less dependence on human psychology will favor strongly typed, formally verifiable and/or high performance languages.³ These are often harder for humans to learn, but they're far better suited to LLMs, which thrive on formal verification and reinforcement learning environments. Expect this to reshape which languages dominate. Economic restructuring of open source – For decades, open-source communities have been built around humans finding connection through writing, learning, and using code together. In a world where most code is written—and perhaps more importantly, read—by machines, these incentives will start to break down.⁴ Communities of AIs building libraries and codebases together will likely emerge as a replacement, but such communities will lack the fundamentally human motivations that have driven open source until now. If the future of open-source development becomes largely devoid of humans, alignment of AI models won't just matter—it will be decisive. The future of new languages – Will AI agents face the same tradeoffs we do when developing or adopting new programming languages? Expressiveness vs. simplicity, safety vs. control, performance vs. abstraction, compile time vs. runtime, explicitness vs. conciseness. It's unclear that they will. In the long term, the reasons to create a new programming language will likely diverge significantly from the human-driven motivations of the past. There may well be an optimal programming language for LLMs—and there's no reason to assume it will resemble the ones humans have converged on. TL; DR: - Monoliths return – cheap rewriting kills dependency trees; smaller attack surface, better performance, bare-metal becomes realistic - Lindy effect weakens – legacy code loses its moat, but unknown unknowns persist; formal verification becomes essential - Strongly typed languages rise – human psychology mattered for adoption; now formal verification and RL environments favor types over ergonomics - Open source restructures – human connection drove the community; AI-written/read code breaks those incentives; alignment becomes decisive - New languages diverge – AI may not share our tradeoffs; optimal LLM programming languages may look nothing like what humans converged on ¹ x.com/mntruell/statu… ² x.com/anthropicai/st… ³ wesmckinney.com/blog/agent-erg… ⁴ #issuecomment-3717222957" target="_blank" rel="nofollow noopener">github.com/tailwindlabs/t…

exactly! never been a better time to bring formal methods to more developers

@levelsio nah it's not, it was intended as a "good first issue" for onboarding people, not as an actual problem to solve

The bot is right here I think

@0_Aakash_0 @thsottiaux 1 + 2 => use agents md 3 => use git and revert if you don't like a diff

Biggest gap: Codex treats every task like a greenfield problem. In reality, 90% of real dev work is modifying existing code within strict constraints. What would change everything: 1. Better repo-level context. Let me tell Codex "this folder is sacred, never touch it" or "always match the patterns in /lib/utils" 2. Persistent memory across sessions. Right now each task starts from zero. If I corrected Codex on a style preference yesterday, it should remember today. 3. A "dry run" mode. Show me the plan and file diffs before executing. The biggest trust killer is when it edits 15 files and you have to reverse-engineer what changed. The model quality is already great. The workflow around the model is where the wins are hiding.

What could we do better on Codex? App, model, strategy and features… what’s wrong in how we approach things that we should improve immediately?

@thsottiaux Model: still bad at writing clean, minimal, elegant code, and keeping a code base long-term maintainable. Introducing (only) the right abstractions, deduplicating and unifying, stuff like that. Feels like the RL is just geared towards immediate problem solving

I think the ideal programming language for agents will - look roughly like TS - transpile to JS - have dependent types like Lean (plus a good built-in model of mutation/effects), so that we can enforce invariants at will I'd love to build that language 😄