Can't help to think of a recent HN post about most AI-generated projects being abandoned within months. Why?
Because value of a project is not in the code produced. It's in the amount of battle-testing that code has seen.
Battle-tested, mature code > fresh rewrite.
Existing Zig codebase has seen X amount of battle-testing. Rust rewrite: 0 (except -I'm assuming- passing test suites). Also:
"this was a port to unsafe Rust, allowing a literal file-by-file migration to minimize risk"
How is that better than the Zig codebase you started with?
Now if that's further migrated to safe Rust, put into production & gathered feedback from lots of users, yes then you have something. As it is, the impressive bit is do such a big rewrite & result seems to work ok. Are Bun users happy with this?
To me it reads like Bun was forked. Will the Zig version survive? Will the Rust one? Both? All options ok.
Edit: and fwiw, I don't think Zig community should get triggered on any of this. It says nothing about how suitable Zig is or isn't for project xyz, and Zig community is big enough to carry their own project & applications besides Bun.
Sunk cost fallacy can be a feature: if you have spent a lot of blood, sweat, and tears on a project, you are more likely to push it through adversity and the doldrums that inevitably one will encounter. If all it took was one of those momentarily brilliant ideas and a prompt on Claude to produce something, there is no attachment whatsoever to it.
Speaking as the ‘average programmer’, I have dozens of brilliant ideas per day that don’t stand the test of time or scrutiny, and the very few that pass the filter don’t seem that interesting days later, or worth the effort at all.
Ideas have always been cheap. Now, proof of concepts have become as cheap. I don’t care about your Show HN unless you have spent a month on it.
In game design friction very important; remove all friction and you don't even have a game any more, you might as well show the You Win screen. My favourite metaphor for it is sex: there is no sex without friction.
What LLM have done is massively reduce the friction of intellectual effort, completely devaluing most expressions of it.
To me the issue is that everything becomes written in the same style pattern. I don't know why but if I spot it I wince internally and immediately skim the post or just outright stop reading. A large part of it is overexposure. For me it's made browsing the internet quite uncomfortable since it's unavoidable.
I mainly spend my online time in group chats these days.
(I’m pretty sure both you and I would “know it when we see it”, but…)
That's not it at all.
The problem with AI slop is that in general it's not worth reading, because to start off even the author deemed the topic wasn't even worth writing to begin with.
Worst, most AI slop blog spam was obviously not even reviewed by the bloggers who prompted them into existence. This means is also content that even the bloggers themselves felt wasn't worth reading at all.
But somehow they expect us to invest our time reading AI slop?
> would spend more time writing than I would have to spend reading
To your point however, the reason people don't like AI generated blogs is because there is a explicit recognition that the author of the blog lacked effort. There is a visceral response for the reader about the social contract "if you didn't spend as much time as I did why should I care about what's written here", it's however NOT that the quality is inherently poor (but perhaps one my insinuate that notion).
Can you point us to a single blog (or even blog post) that is generated by AI that is excellent quality? Or even average quality?
Quality is a bit nuanced but that quality of AI generated content is subpar to expert output is fairly established.
The implications of this ever becoming false amounts to GAI.
I can and I will say that, if not only for the fact that, in the eyes of many people, AI and the botched launch of the past few years has incurred a great amount of distrust. But, going further, the vast majority of AI-generated blog posts are lower quality, because they lack human thought and effort behind them. I'm not saying AI is completely incapable of writing what a human can, but we can't relate to how it "thinks", if you can call it that, and if someone is going to put enough effort into curating an AI's output and coaching it to make it output something that is really of a high quality... they just put in all of the human effort it would have taken for them to write it themselves.
I also don't think this should be construed to mean that human-written posts are universally good. AI slop is just the latest and most farmable iteration of a long history of badly written and poorly thought out content on the internet. In some ways the average AI blog is probably more coherent than any flat earth blog.
I also think that that visceral disgust at consuming AI generated work points to something else. We are all still trying to grapple with the ethical boundaries of what is okay and what isn't okay to do with AI, but I think most people feel deceived when they find out they're watching an AI video, or reading an AI blog post, and rather than assuming people are wrong to feel that way, we should consider that their feelings on the matter do matter. Nobody wants to be fed algorithmically optimized fake slop by YouTube, and that's okay.
Yes. I'm as pro-AI coding as people come, but this is the part that bugs me too. If you whip something useful up in a weekend, great!
But you don't have to present it like you are building an actual product. It's fine if no one else knows about it. Because the fact is, most people don't care, even before AI. Building for yourself is fine.
I dunno, this idea guy seems to have some really great ideas, what's wrong with you skeptical programmers who aren't on board implementing his ideas for equity?
I think it's more than that. These greenfield projects are actually things that, up until the inception of LLMs, they were not worth creating.
With AI code assistants, the cost of developing them is lower, but in the end you still end up with a project that no one bothered to create.
I hate ai so much because its so easy to generate quick slop that "appears" functional.
Obviously they have to start somewhere if they want to get to safe rust with a considerable degree of battle testing. So they decided to start with just a transliteration and go from there.
I think the Zig people are really just concerned that maybe Zig itself is a DOA language because it doesn't offer enough over C for any serious use and their flagship project has now abandoned it.
Just search "segfault" on the Zig issue tracker and you'll see why people are starting to be skeptical of the future utility of such a language in the face of something like Rust.
Zig has 110 open "segfault" issues [1] versus Rust's 175 open "segfault" issues [2]. So, by your logic, Rust is also bad.
edit: I was just trying to point out that the parent's "just search segfault" argument is lazy. Also, Zig is still in beta.
[1] https://codeberg.org/ziglang/zig/issues?state=open&type=all&...
[2] https://github.com/rust-lang/rust/issues?q=is%3Aissue%20stat...
It's not even wrong.
I see Rust encroaching in proposed transitions. It may even happen. That said, it is a poor match for it compared to something like Zig (or Odin). It's hard to make the new Rust code use existing allocator abstractions (so now you have two systems doling out memory, how do you reliably free composite objects with memory from both? How do they share?) and you increasingly have to either abandon any actual benefits of the borrow-checker, or invest increasingly heavily into sufficiently fat bindings to wrap your existing C/C++ in a way where the borrow-checker can assist you. That's before we consider the complexity of the language - I'd doubt a seasoned C programmer has much trouble deciphering Zig or Odin FFI bindings, but in the case of Rust? Yes, there is real friction.
Also if you really value predictable- and higher performance, being in more in control of memory allocations and cleanup is preferable. This is the direction both Zig and Odin cater to.
If you asked me what solves the most issues without adding too many new liabilities, I'd say Zig (or Odin). It would simply be much, much easier to transition a C codebase to either, and either would bring a much improved stdlib with pluggable allocators capable of leak-detection etc.
Now, mixing different allocators is a different beast, and much less supported. But it sounds like you are very much not interested in this use case, right?
Huge problem with this is that typically safe, idiomatic Rust looks nothing like unsafe Rust.
On the other hand, as a corporate backer for Zig, TigerBeetle is definitely a big deal.
But in terms of exemplary and copyable projects in the ecosystem I would think something like Ghostty is the safer label for "flagship".
On the other end, Rust to me felt like "better C++" - outside the embedded niche, aimed at complex multithreaded code that has to combine high performance with not catching on fire because someone fucked up concurrency once again.
But the main issue I had with Rust - that it's frankly a bitch to write, nearing Go levels of awful, only worthwhile if its paradigm is buying you a lot - is diminished if it's an LLM that's doing the bulk of the line to line writing.
And, on the other end, C's warts, footguns and ancient quirks also matter less if you have an LLM plow through it.
So, the niche for Zig does seem to be shrinking. The window for it to establish itself might be genuinely closing now. Which is a shame, because I like the idea of having "better C" a lot. But all of this drama sure isn't helping it gain traction.
Pre-2022, Zig was doing decently, but not particularly well. It didn't have Rust level of enthusiasts and ambassadors (love them or hate them, they did succeed in driving considerable Rust adoption), it didn't have a major corpo backing it, it had too much API instability to be truly relied on. Picking a stupid fight with Bun/Anthropic and doubling down on it isn't helping with any of that.
I also don't think compilation time makes for a good moat for agentic AI coding? Like, sure, less time wasted = better. But LLMs don't perceive time as humans do. They don't have the human "40 minutes of compile time = a hard forced context switch" quirk. The state of an LLM agent is as "stale" after a 40 minute build as it is after a 40 second build - no attention penalty for getting distracted.
There is a hard "wall clock time" iteration speed penalty, but I expect LLM coding to be more agentic, not less. In which case a single sub-agent stalling might not matter much? The orchestrator AI would just keep doing other things, and come back to the stalled sub-agent when it's ready. Once again: long stalls hurt the worst if they route through human attention. The less human attention there is in the system the cheaper they are.
1 minute skim of that surfaces aviaviavi's comment on moving to Python not Rust:
Main factors were (roughly in order):
- None of us are experts in Rust, and we're all solid at Python.
- Rust felt like an under-correction for what we wanted (get all friction in front of the LLM out of the way).
- Our high-performance stuff is not being migrated at this time (Scarf Gateway), so we're just talking about basic CRUD backends here. Basically any language will workI used to think that there's a a room for better C -> Some unrelated complains about Rust and Go -> C has footguns, but they don't matter that much because I choose to not write my code myself anymore -> Therefore there's no room for better C.
You hit the nail on the head there. Zig is 10 years old now and it’s pretty clear that the industry isn’t biting, compared to the behemoth that is Rust. Between Rust, C, and C++ there is very little room for another language with a woefully incomplete library ecosystem to establish itself.
A true competitor would need to offer genuine extra value, such as dependent types or other formal verification features, to carve out a niche.
Zig isn't finished yet (they still have not released a v1.0). They're still iterating on the language itself and want the flexibility to make backwards-incompatible changes while they do so.
So in a sense, they have not yet asked anybody in mainstream industry to "bite." After v1.0, when there's an understanding of stability and ongoing language support, industry adoption or lack thereof might become a relevant metric for measuring the project's health. But right now that's not relevant at all.
You are the typical mark for hype cycles. Get a clue will you.
Nope. I was on a Python project in 2006 and earned a paycheck doing so.
> Because value of a project is not in the code produced. It's in the amount of battle-testing that code has seen.
I'm not convinced this explanation is self-evident enough to assert without any justification. I can think of at least one other plausible one, which is that maybe most side projects in general get abandoned after a certain amount of time, and being able to write the code a lot faster means that the point of diminishing returns for personal utilities, enrichment, or pleasure are reached a lot faster.
In contrast with the Zig codebase, you now have clear well-scoped unsafe boundaries you can iteratively fix one by one. This was not the case before.
This is not done by blindly porting Zig code 1:1 and calling it a day. You do have to make conscious decisions about code architecture to manage Unsafe code, since you need choose the right invariants for your Safe Rust code to conform inside the module (Note that unsafe pollutes the whole module containing it, not just the code inside the unsafe block!)
EDIT: You can't be serious people. Rust unsafe is safer than C, if for nothing else, for knowing which pointers are aliasable.
> We can gradually refactor it to reduce unsafe usage and look more like idiomatic Rust after Bun v1.4 ships.
What the rewrite does is make the unsafe code greppable, which is a necessary first step to eliminating it and one that's actually achievable rather than going straight to idiomatic.
Every successful refractor takes this form of stepwise changes that leave the behavior intact. It just so happens that in this case the first stepwise change was the implementation language.
I'm gonna offer an alternate theory. Because AI-generated projects are so cheap, there's no need to amortize them by advertising and creating a community. It works for you, you don't change your workflow, so there's no need to expand it. In this model, most AI-generated projects are done within days, not abandoned.
Creating software with AI is super easy--plan, prompt, test, go, go, go!
Owning software means you're responsible for maintaining it over time, fixing edge cases, operating it well, and more.
If you're building a one-off custom webapp to meet your needs, create away. If you're writing software for a business to run on, you're owning it. My fav article on this topic is this post[1] on durable vs disposable software.
0: https://www.linkedin.com/feed/update/urn:li:activity:7482123...
1: https://www.honeycomb.io/blog/disposable-code-is-here-to-sta...
Because most projects are abandoned within months. Why should they be any different in that respect?
I've gone back to Node.
There was a poll on r/bun with about 2000 votes and only about 30% of users voting they were going to use the Rust version. Can't seem to find it now.
Edit:
The poll was deleted
https://www.reddit.com/r/bun/comments/1u3j4d7/are_you_going_...
and the rust version has been live in claude code since june 17th.
They’ve just found a way to explore that logical fallacy even faster.
Rel: https://www.joelonsoftware.com/2000/04/06/things-you-should-...
In hindsight having automated auto complete rewriting your code base wasn't something on 2000's radar.
Now switching from language to language is much easier. Just for Rust, there was Ladybird and Bun complete rewrite, that ran into zero things that Joel rallied about.
People did this also before LLM, but the difference is that now the prototype is a fully functional product in the technical sense whereas before it was little more than a glorified Hello World. The human effort and calendar time used remains roughly the same.
There's gonna be amazing products made with LLM, but it'll take some time. Not as long as it did before, but still significant time.
The idea that "anything other then pure safe Rust is useless" is common (even among some Rust proponents, but generally not the most experienced ones), but it's a pretty fundamental misconception of what Rust actually offers. Safety is a spectrum, not a binary, and while the extreme end of "everything is guaranteed to be safe no matter what" is nice when you can get it, Rust is literally designed to solve the problem of giving you the ability to slide along the spectrum to calibrate to the most amount of safety you an achieve rather than being all-or-nothing.
If you still think there's no value in enforcing safety outside of the lowest level stuff like JIT, I'd suggest being more explicit about why you're confident that memory safety bugs wouldn't be a concern outside of those contexts. I've yet to hear an argument for why I shouldn't be concerned about memory unsafety in even relatively mundane code in memory unsafe languages that doesn't basically boil down to "just be really really careful", which I'd argue has been empircally shown to not work even a little bit no matter how skilled the programmers writing the code are.
(I think wrapping a large, complex C/C++ codebase is where Rust often shines, if you build the right joiner abstractions. PyO3 is a really great example of that.)
> heap-use-after-free crash in node:zlib when calling .reset() on a zlib, Brotli, or Zstd stream while an async .write() is still in progress on the threadpool
https://github.com/spaceraccoon/vulnerability-spoiler-alert/...
If you look at the fix you can see its all in their zig codebase:
https://github.com/oven-sh/bun/commit/621c4016218bb782e05907...
What is kind of funny is that nodejs also had a basically identical bug with an almost identical fix:
https://github.com/spaceraccoon/vulnerability-spoiler-alert/... https://github.com/nodejs/node/commit/53bcd114b10021c4a883b0...
But now the interesting question, how does the code look like in Rust?
https://github.com/oven-sh/bun/blob/8f1a9540fdff25410506de76...
It has the same guard in place as the zig and c++ versions, the rust code also just calls into the zlib bindings after the "write in progress" check.
So in this case at least the same exact use-after-free would've happened and they don't win anything from the rust port.
Another one was this:
> crash and out-of-bounds read in Buffer#copy and Buffer#fill when a valueOf callback detaches or resizes the underlying ArrayBuffer during argument coercion
I think ths is the fix:
https://github.com/oven-sh/bun/commit/79522ab6c579736dc239fa...
But the bug here is in C++ bindings, Rust wouldn't have helped here either.
Last one:
> double-free crash in the CSS parser when background-clip had vendor prefixes and multi-layer backgrounds
Fix: https://github.com/oven-sh/bun/commit/912970c98437e418a95b6b...
Code side-by-side:
Rust: https://github.com/oven-sh/bun/blob/8f1a9540fdff25410506de76...
Zig: https://github.com/oven-sh/bun/blob/912970c98437e418a95b6b5b...
I can't judge the Zig code, perhaps someone could say if this was a "beginner" mistake.
But this is at least one case where Rust would've helped, although even that is a bit complicated considering stuff like bun_ptr:
// Lifetime-erasure helpers (RUST_PATTERNS.md §6/§18) — re-exported here so
// crates that already depend on `bun_collections` (logger, css, js_parser,
// crash_handler, watcher, http_types) can route the borrowck-dodge through
// one centralised `unsafe fn` instead of open-coding the lifetime cast.
pub use bun_ptr::{RawSlice, detach_lifetime, detach_ref};
It's also outside the scope of the project if they're using Webkit's engine for that part. Which means Bun itself isn't a JIT, it's all the stuff built around the Webkit JIT, so whether or not Rust is useful for the JIT is entirely immaterial to the question of if Bun would benefit from Rust.
I think a lot of people will, but those who do probably weren't the target audience for Zig in the first place?
I still remember the Twitter dev blog where they abandoned Ruby/Rails and the damage that did. It turned out Twitter was doing a lot of stupid things and there was a mismatch of tools and their goals. They loudly blamed the tools and people ate it up because Twitter was big, visible and adored at the time. Their conclusions bypassed most people’s ability to reason.
Anthropic/Bun are big, visible and adored…
I saw a lot of RoR companies/users thinking “should we do the same?” without even realizing that they do not have the same twitter scalability problems.
The same engineer at Twitter decided early on that no distributed messaging technology was good enough for Twitter, so they wrote their own. It fell over and they threw it away and wrote their own again. It fell over and they threw it away and now they use mainstream tools.
It is in the marketing. Most software engineers are not skilled at marketing, do not have a large audience, and are not willing to spend money on advertising. It has nothing to do with code quality.
It's not better, it's worse given the average bear's assumption about a rust project.
Claude Code was a vibe coded experiment, a "what if", that basically consumed software engineering in six months flat. Not because it's durable (it's not), but because the value it provided was so overwhelming.
People will use bad software if the value it provides is high. People will avoid the most durable and battle-tested software ever written if it doesn't actually provide value (solve a problem for them).
You are acting like they need to complete everything at once...why?
Bun (rust) is not even released as stable yet and getting extensive usage on Claude code. They are making improvements and fixes. So what's the issue here?
For context, I'm using Codex and have no interest in either Zig or Rust, so just observing this drama from the sidelines.
Did we just read the same blog post? I see no assertion in it that Anthropic is in the programming language market, rather that this rewrite was a marketing opportunity for them they were happy to lean into.
Anthropic absolutely is in the programming language market. If/since AI makes rewrites to certain languages relatively easy, a success story will tie the given language(s) to the given AI company.
Rust may have a tremendous success in the future, because it's much easier to write it with AI (ignoring for a moment whether that's really a good thing). The implication is that Anthropic has a stake in Rust's success.
Also, to be kept in mind that devs advertising successfull rewrites often hide some aspects that are unfavorable to the narrative; typically, how bad was the code before the rewrite), although there are other (significant) aspects that have been omitted.
> Zig's response is a sour opinion piece full of personal attacks.
I take you haven't read Andrew Kelley's article (here: https://andrewkelley.me/post/my-thoughts-bun-rust-rewrite.ht...).
Summary:
- Jarred has written Bun with very bad engineering standards
- Jarred has managed public relations very poorly (e.g. ghosting the Zig foundation)
- When they rewrote the project to Rust, and described Zig as poor choice, there has been a negative fallout for Zig
- The ZSF is obviously upset because of the poor publicity
This is summarized at the end of the post:
> Zig users who knew next to none of these facts and have only the surface level understanding that an ex-Zig-user is getting trashed by the language creator. Such people might reasonably worry that might happen to them
As a matter of fact, I also believed the same after reading's Bun's post. This is undeserved though, and that's what Kelley explains.
There's definitely a personal attack somewhat, and this is addressed in the last (added later) section.
This doesn't even make any sense. The part that you're quoting[0], is Andrew commenting on the fallout from the blog post he made. How could you have thought something about a blog post that hadn't come out yet?
Also, if you are talkinga bout the post Jarred made, it was extremely charitable about zig: "Zig made Bun possible. I would never have been able to build this much in 1 year if it wasn't for Zig."
[0] "The other critical mistake I made with this post was failing to consider the rather obvious and important point that this might affect Zig users who knew next to none of these facts and have only the surface level understanding that an ex-Zig-user is getting trashed by the language creator."
Yes, that's the sour opinion piece full of personal attacks.
"You're holding it wrong."
>Jarred has managed public relations very poorly (e.g. ghosting the Zig foundation)
What obligation do you think he has here? Which direction should these good relations flow?
I'm also an outsider here, and reading this post was kind of shocking. Can't believe someone would attack your open source code. It's everything normies hate about ornery IT people.
This premise makes no sense. AI makes rewrites to any language easy.
The LLM companies have truly astounding power to now steer the direction of the entire industry. It should worry all of us.
I actually love the use of ghosting in this post. It is almost a Freudian slip about how Zig looks like from the view of outsiders. Zig moves exactly like how toxic exes do. They point fingers, make passive-aggressive statements, unnecessarily air out dirty laundry, and downplay all of the good their partner has done during the relationship.
It’s interesting that Rust could become the most deployed but the least written (by humans) programming language if the dreams of AI bros come true.
If AI gets good enough to competently translate other languages to Rust then there is no point writing in Rust (a language with a steep learning curve and is high friction in use), you can just write in a low friction language like C, C++, Odin, Zig, … etc. and have AI translate it to Rust catching all the memory bugs in the process.
Anthropic does this to sell LLM rewrites and make them look better than they actually are, Zig being the source language, they are a collateral victim of that misleading advertisement. Of course it's unfair to them and of course they should highlight this.
The cost was only provided as an honest estimate of what it would have cost someone else at time of writing, which I thought was fair.
The number is peanuts relative to the cost of engineers working on the project. I find it odd that so many people think this cost number is some sort of smoking gun.
Here are the comments:
https://news.ycombinator.com/item?id=48251340
https://news.ycombinator.com/item?id=48241734
https://news.ycombinator.com/item?id=48240996
Now he published it; it's a hit piece. Damned if you do, damned if you don't.
We’d like Zig to be a project with steady and technically driven leadership like Rust, but Kelley has made clear (many times) it’s more of an egoistic vanity project like Elm, designed to cater to the emotional needs of the BDFL.
Incredible the different takeaways people get from text content on the internet. I'd say it'd be more like if you moved from Unity to Unreal and then Unity made a blog post saying they were happy about you moving to Unreal, publishing they think it'd be a win-win, then outlining why they think so.
I mean, that makes it all sound very polite and dispassionate, but Andrew's piece was anything but. I have no dog in this fight, I don't use Zig, Rust, Bun or Claude, and initially I thought the bun rewrite sounded like a terrible idea. I changed my mind after reading the piece about the migration - it was very interesting and the process was obviously quite thoughtful. Andrew's piece made me want to take a shower afterwards.
I'm exactly the same person as you, yet I still think Zig's post wasn't a "hit piece" at all, at least how I understand that term to be. They outlined the history from their point of view, talked about what they didn't like with how Jarred acted and worked, said they were happy about them moving to Rust, then basically said "Good riddance".
Everything is so drama-amplified nowadays, nothing can just be "They're a different person, they work in a way I don't like, but I'm happy they found a better language, good riddance" and that's it, no, instead this is a "hit piece" "trying to assassinate someone's Good Character" and what not... It's so tiring.
> I described him as someone who had strong "beginner energy"
> groomed from a young age into uncritically embracing the Silicon Valley mindset
> Jarred was a stinky manager. Poor communication, unrealistic expectations, low empathy, no experience. Just a total shit show
> We became increasingly horrified at the programming practices we saw in Bun's codebase. Hacks on top of hacks
> Jarred was already writing slop well before he had access to LLMs
> While I resent Jarred for making Bun into an embarassment for Zig
Let's say the supervisor wants you to write a new microservice. Do you refuse to do it because the supervisor smokes cigarettes and you're an anti-smoker? I think that if you have objections, you should refuse only on technical grounds, not personal.
It is incredible isn't it.
"Jarred was already writing slop well before he had access to LLMs"
"The grapevine was large and healthy and full of juicy grapes, and all those grapes contained the juice of the same message: Jarred was a stinky manager. Poor communication, unrealistic expectations, low empathy, no experience. Just a total shit show, from an employment perspective."
"at some point they would sell out (let's be honest, their vague "sell some cloud something" business plan was a farce from the get-go"
"he was essentially groomed from a young age into uncritically embracing the Silicon Valley mindset"
There is more but I'll stop quoting to not end up copying the whole thing.
Yeah, and perhaps also because your point(s) wouldn't make much sense if people ended up reading the whole article, rather than your cherry picks ;)
You're accusing me of cherry picking, can you explain how these are cherry picked ? do you even know what cherry picking means ? maybe explain the important context for "Jarred was already writing slop well before he had access to LLMs" that I omitted apparently.
Yeah, exact words you would expect from someone who is happy about a win-win situation.
People are entitled to their emotions. The question is whether the bitterness is warranted. I think it is.
I'll admit to thinking that the Rust crowd often has a toxic atmosphere, but Zig came off as worse in this exchange.
It seems to, on the surface. It would have been dumb to pass the occasion to look good. But really, the core message is that they are better off with rust after the rewrite, but they are better off because they worked on making the rewrite look better. Work that they could have done in Zig too. Of course when you are the creator of Zig, that may feel quite unfair and you should highlight it.
> The Zig blog post was heavy on personal attacks
I agree this doesn't look good.
> Between the two, the Bun post is a lot more compelling from technical and professional perspectives.
The Bun post is a well polished marketing piece from a trillion dollar company that subtly and misleadingly throws shade at Zig (while looking complimentary on the surface, but make no mistake here), a collateral victim of false advertisement for Anthropic's LLM.
Andrew's post is an emotional response (that didn't target "professionally", it's also not on Zig's blog), written too early that could have done without the personal attacks which are bad and completely get in the way of the important message.
Andrew's post looks immature because of the unprocessed emotions, and he really should stop the personal attacks, they don't bring anything good. Anthropic's post is good looking lies as usual.
Then highlight that, don't repeatedly insult someone. If Andrew thinks the same kind of ai-assisted improvement would be possible in Zig, and that avoiding the kinds of errors migrating to rust achieved would be possible in Zig, he should demonstrate it. And I don't necessarily mean rewriting all of Bun in "better-zig", but like, if you're going to say "this project is bad because it is badly maintained, not because the language has limitations" then demonstrate something to that effect.
The only technical detail I recall from Andrew's post is that zig has faster compile times, which may well be true but what do I care?
What Java, JS, Python and C# all did to conquer the industry from a C++ dominance was to provide safety harnesses for less "perfectionist" workers to fumble around without causing a mess, to write C and C++ in an increasingly hostile world we realized you needed a lot of craftsmanship, the performance benefits outdid and kept the latter languages relevant for a long while.
Still, the performance/predictability penalty didn't give way so Rust (and Swift) came into play. They don't have as many unpredictable performance characteristics as the previously "safe" GC languages but still provided more or less the same guarantees (in some ways perhaps even better for Rust).
The brilliance of the Rust ideas did start a bit of a cambrian explosion of languages in that niche, most of them however targeting a bit more of a craftsman position than Rust (that came out of distinct industry needs).
The problem as the article illustrates, in car terms.
If Java,JS,etc are mostly "regular safe cars" and C/C++ a two wheel motorcycle.
Rust is perhaps a rally car (fast but still a car so occupants inside are well protected) whilst Zig really is a quadbike or open wheel cart, not as unsafe as a two wheel bike since you won't slide for the smallest oil/ice patch but flipping over is still dangerous as hell.
And that takes us to the crux, so many developers who love the craft and perfection (and don't live under- or perhaps care of- financial constraints) think that "good careful" developers is all that's needed and don't see dangerous language designs as a problem.
I'm an older developer, and given that I can write "good careful code", but 90% of the time it's also a matter of time and financial constraints so I wouldn't trust mine (or anyone elses for that matter) code written under those "industry" conditions.
I think Zig has a lot of nice perks, but it was obvious from day 1 that it's very much for people that love their hacking freedom over writing code for todays hostile world.
The state of computer security has moved on from the old model of just patching bugs when you find them. To now where we need to systematically prevent them from happening to begin with.
- any GC'ed language can manage memory for you if you want
- My first rust project (a gui app in GTK) managed to segfault just fine in spite of Rust (no unsafe blocks on my part, not deliberately trying to break anything).
- I think the state of computer security has moved on still, we now rely on LLMs armed with various tools to pick apart and try to break our code AND to generate our code -- it is not at all obvious to me that banging your head against the borrow checker is a worthwhile tradeoff in this new world.
Arguing that a product that sells itself as improving programmer productivity by writing the code for you has no stakes in "the programming language market" because it doesn't sell a programming language of its own is impressively shortsighted. Especially when the leader of a programming language has openly stated their dislike of vibecoding, critisized the industry, and the language project itself rejects PRs made with the product being sold.
Jarred's post about Bun-Zig-Rust post was technical and polite.
Andrew's post in response was anything but that.
If everyone sees the post as "polite", most of it probably been written by LLMs, as they remove anything that could be seen as "nonpolite" and human. Meanwhile, engineers who just want to publish their own thoughts and feelings on a subject, will be filled with stuff the public sees as "nonpolite", and since those hard edges weren't trimmed before the publishing, we can then assume this is actually a genuine person's thoughts and feelings.
For shits and giggles, I asked Sol xhigh what it thought about my previous comment, giving it a "6.5/10 for politeness", saying "it’s polite in tone, but somewhat provocative and reductive in substance.".
Maybe this filter should also include provocativeness and reductiveness, and if it isn't provocative and reductive enough, surely it's a LLM? ;)
I browsed through the Bun code following Kelly's post, and decided to have Codex replace all my Bun usage with Deno.
The memory safety aspects could be discussed. Arguably they could have had equally good memory safety by employing AI, tests and fuzzing (the Zig integrated fuzzer that the Zig team suggested they use, not just the high level fuzzing they were doing)
For this kind of project I do think using Rust is a good idea. At the very least because a project like Bun probably can benefit from a more mature language.
But I also think Andrew’s perspective of this process has been essential to understand what happened here, and though he could have been nicer with his word selection in a couple of places (he doesn’t have the clout of Linus Torvalds to get away with it), what he wrote absolutely needed to be said. I find it annoying that people dismiss it as personal attacks. If being a bad manager is the direct cause of a poor working relationship and bad engineering results, pointing it out is not a personal attacks. It’s essential context for understanding what happened.
The post did no such thing — it spread rumors and leaned into gossip. There’s no proof or evidence or examples whatsoever offered by Kelley except Jarred’s own public words, which means the post didn’t reveal or expose anything about his management.
Remember the days where teams would adopt technologies based on how familiar the members are with them? "Now that the AI is here" and is the one writing code, to the point where Linkedin devs flex how it's been months since they touched source code, teams adopt technologies based on how familiar AI is with them.
No, they're intentionally in all the programming language markets.
Just like Google might sell ads on (approximately) all the websites, but they don't particularly care which website you visit.
Other than JS (which they obviously do prefer), this rewrite would have taken place no matter what programming language was originally used for Bun.
The reason for the rewrite was marketing, not engineering. The justification after the fact can be done no matter what language they were rewriting from.
Zig -> Rust : "We had all these memory errors"
Rust -> Zig : "We had poor iteration due to compile times"
Java -> Anything : "Memory is at a premium when we're trying to run a fleet of agents"
Anything -> JS : "We wanted a single language to optimise our agents for"
You get the idea.
I mean, they did buy a JS runtime, so surely they must care more about JavaScript and TypeScript than other languages, right? Otherwise that move makes 0 sense.
Maybe this part from their marketing post about the acquisition is just a straight up lie I suppose?
> Together, we’ll keep making Bun the best JavaScript runtime for all developers [...]
Anthropic's posts were sanctimonious, self-serving, tone-concealed delegitimisation of Zig. Kelly's post was a strategically poor but sincere individual understandably frustrated at this concealed attack, expressing his honest feelings about the situation.
Not sure; it has some elements of personal issues, but they're followed by a rationale from the author.
Honestly, seeing the project lead (Andrew Kelly) take a stand against poor engineering practices without any equivocation makes me more inclined to want to use Zig - their values (in this regard, at least) align with mine.
He also substantiates what many of us are saying to all these "Very Senior Chief Engineer with 40 years experience" who are boasting of 10x productivity: these people aren't reading the code they are generating, and were producing slop even without AI.
When I read the post, my first thought was that I wouldn’t want to build things in Zig, because any technical decision I make, good or bad, might subject me to this kind of article from their BDFL. I can’t conceive of the leadership of the Python or Rust or any other community I’ve ever worked with doing something like that.
What misleading stuff? Makes Zig look bad how?
The posts I read were appreciative to Zig.
The only “misleading” piece of either blog post that I recall was the Andrew Kelley claim that Bun wasn’t fuzzing, which was easily refuted by pointing to their fuzzing work.
If there’s something more then I’d like to see it, but every time I ask nobody can point to anything other specific.
As for ghosting in meetings: sure, that seems bad. I would also be upset if someone did that to me. But you can state that factually without making it into a personal attack. It would even be more convincing.
I think you've missed the core thesis of the article. That post _wasn't_ technical writing. It was marketing disguised as technical writing.
Compare Cloudflare, the Google Chrome Security blog, etc.
Presenting only one side of argument (only pros, no cons, etc.) is deceptive and dishonest. The fact that they were incredibly focused on build time in Zig and didn't even talk about it as a tradeoff going to Rust is very telling.
At least for Rust, part of this is because there is no BDFL, by design. Python has moved away from the BDFL model as well, IIRC. Individual contributors can get mad and write angry personal attacks, but there’s no face of the language like there is with Zig.
(It’s of course a tradeoff, since Rust moves more slowly than I think a lot of people would prefer.)
Insane that people + tokens are slobbering to rush to Clownthropic’s defense when the whole migration and subsequent blog post was just sour grapes about the Zig project’s no slop policy.
And this is a warning shot from Anthropic intended to have a chilling effect, we have tens of billions of dollars at our disposal and if you take any stance we don’t like that undermines our narrative we will fuck with your shit and throw billions of dollars of muscle at rewriting you or trying to make you irrelevant.
I read both posts, and didn’t leave the Bun one with a negative opinion of Zig. But I did leave the response post with that opinion.
It was serious enough that Jarred showed up to post receipts with very little commentary, so as not to distract from the receipts. The charge of professional dishonesty is very strong.
I think there were valid technical and professional criticisms in that post. For example, “Oven’s working culture was poor” is an excellent thing to communicate that I otherwise wouldn’t have any sense about.
At the same time, I also think they were essentially wrapped in an insult sandwich: the post starts with personal swipes against Jarred (who, again, I don’t know) and end with an insult to the reader (who is expected to not believe their lying eyes about all the personal attacks they just read).
I knew it was gonna happen at one point, guess I didn't believe it'd happen so soon, but I still can't believe that nowadays people make choices about what programming language to used based on what semi-celebrity they like the most, and it's all about emotional arguments. What happened and since when is this the way people make technical choices? I feel like I woke up in an alternative universe.
But it's actually as simple as: Jarred's post was mature and didn't throw shade; Andrew's threw quite a bit of it while insisting it did not.
I and many others don't want to be slandered or trash-talked if we moved away from a language we previously chose. That can and has had actual business impact on projects / companies in the past. So naturally, people will judge you if you cannot be mature when responding to an event that made some splash in the ecosystem.
The language in question here is maintained by a BDFL, which means that one person has outsized influence on the language, and it's direction.
In this context, I find it reasonable that if someone is ticked off by that BDFL, they might second guess the direction of the language itself. Since the opinions and emotions of that BDFL _will_ end up in the language and it's community.
This is different than some un-associated influencer having an opinion, and using that to choose a language.
Seems like a strange perspective, isn't it expected (and even wanted) that if you have a BDFL, they have the most influence on the language and its direction? That's why they're BDFL, that cannot be outsized, it's perfectly sized for what it's explicitly trying to be, that's the entire point.
> In this context, I find it reasonable that if someone is ticked off by that BDFL, they might second guess the direction of the language itself. Since the opinions and emotions of that BDFL _will_ end up in the language and it's community.
Yeah, I suppose in the new daily reality where we care more about what opinions people hold, rather than what quality, reliability and so on they actually produce, this does make a lot of sense. Personally I never used Linux because of how much I love/despise Torvalds, I've basically never cared about what he thinks, never thought it was important either, as long as Linux continues to work for me.
(I also don’t have any opinions about micro-celebrities or whatever else. I don’t know Jarred or Andrew, and I have priors about JavaScript that in any other context would naturally bias me against Bun. But the Zig post’s flaws are, in my opinion, not ignorable.)
What was the technical parts of Zig's post that made you leave with a negative opinion of Zig then? Something doesn't add up here.
> When I read the post, my first thought was that I wouldn’t want to build things in Zig, because any technical decision I make, good or bad, might subject me to this kind of article from their BDFL. I can’t conceive of the leadership of the Python or Rust or any other community I’ve ever worked with doing something like that.
This is the negative opinion in question.
Yes, on the one hand here's "Structure and Interpretation of Computer Programs" and on the other hand here's my blog "embedding-shape is a stinky slop beginner shit show"
And yet you got a negative opinion of me from the "embedding-shape is a stinky slop hack beginner shit show" post rather than SICP? I feel like I woke up in an alternative universe!
BTW the rhetorical device of misrepresenting what someone else says as something much weaker or incorrect and then arguing with that is usually called “strawmanning”. Just thought I’d point that out to you in case you weren’t conscious that this is what you’re doing.
> We wouldn't have gotten this far if not for Zig, and I'll always be grateful. Until very recently, programming language choice was a one-way decision for a project like Bun.
(Edit: I don’t understand the relevant of these links, to be clear. PyPI is a PSF-hosted project, but that’s because PSF is a legal and fiscal umbrella, not because they pay me for my contributions to PyPI. They don’t.)
As someone who's been following Sumner's work closely for years, Kelley's accusations are very much true even if unkind. While the results are useful and cool, it a wankfluencer op from start to finish. I dare you to refute thus.
And I say all this as someone who does agentic development 8hrs a day and someone who always pestered my team to opt for Rust and Deno instead of Node. Call a spade a spade, the rewrite was poorly justified and one in a long lines of successful psyops Dario and co. cooked and delivered.
Now, would Andrew's message have been better received if it had better "decorum"? Maybe. But I'm glad he stayed honest to himself instead and didn't have a PR team ghostwrite his thoughts. You have to appreciate that.
If there's one thing I learned in this debacle is "I should spend 1-2 days and send to a close friend before hitting publish on a firey reply." The way Andrew rephrased the closing section is the kind of thing I should publish on the first edit in similar scenarios.
I assume Andrew's goal isn't to be a viral influencer but to achieve some type of long term impact or goal. Programmers don't pick languages based on maximal vitriol and if anything do the opposite.
What I found helpful were his explanation of how the interaction with JavaScript’s garbage collector created unique challenges for Bun. Andrew did not address this point at all. It was also helpful to understand how the test suite covered the new code - many people had assumed the tests were also vibe translated and couldn’t be trusted. Andrew pretends he didn’t understand that tests don’t catch all bugs, which is true of all software including Zig.
To me this whole exchange is mostly the typical “memory unsafe languages lead to time consuming and disruptive defects that can be almost entirely prevented with a choice of programming languages” versus the “git gud and don’t write bugs” response.
Layer on the AI tension, Anthropic’s involvement and Andrew’s classic Linus impersonation and of course its viral.
Does that include Claude itself? Half joking aside, my main concern remains that both OpenAI and Anthropic practice this fear mongering as strategy at the executive level because they have to. A corporation is a different beast. Not human, exactly. Not AI either. What happens when a corporation starts being informed by the AI it is building?
If you want a lens into master craft corporate human slung bullshit, read this: https://www.theverge.com/podcast/944138/microsoft-ai-ceo-mus...
In this, not only did the interviewer admit he knew Suleyman had written about the issues he talks about in his rebuttals, he then says he's only asking (the hard question) because the "audience" wants it.
Suleyman's response talks about taking "accountability for the things that we build" and the "types of problems that we choose to work on," it highlights the fundamental flaw in the cloud-rented AI model.
In that ecosystem, "we" means a handful of corporate executives deciding what tools the rest of the world gets to use, how they operate, and what data they extract. All based on the profitability of the corporation. It is the absolute antithesis of a sovereign architecture where execution happens locally and the user dictates the terms of the system.
They are coming for open models. It's time to harden the gates.
What I do care about is technical details. Jared shared some motivation as to why they ported to Rust, and I think they look valid (even if provided with sparse evidence). But I have not seen any sort of refutation from Andrew that these are not actually issues or how they should be solved in Zig canonically. I'd really like to see an exploration of these arguments, specifically pertaining to the Zig code as it was written for Bun.
The Bun project was started in Zig by someone with a lack of experience using the language, despite the massive scope and complexity, and was effectively a rewrite from another language in the first place.
From the Bun post:
> Bun started as a line-for-line port of esbuild's JavaScript & TypeScript transpiler from Go to Zig.
Then, a few years later, the entire codebase was thrown out to do another rewrite in another language.
What is there to address?
They needed 10x speedup and it was not possible with the current language. And they chose Go, because they could retain 1:1 architecture in most cases. So whether or not it was well engineered, is not so clear. They did not choose Rust because they would have needed to redesign the whole architecture.
In the case of Bun, it smells more like bad engineering, so I am not sure if these are comparable.
And also he implied he doesn’t even want to engage with anything relating to this since Jarred is toxic and there is no value in the debate.
I think these points are fairly clear from his blog post
If he doesn't want to get involved, then why even write this piece?
If you spend X amount of years building something, and someone you know to be a mediocre dev trashes it in an effort to enrich themselves, you're allowed to expose the things you know about them. End of story. I wish more people would throw a tantrum. We should expose all these charleton and thieves.
That’s strange because in this (and Andrew’s in lesser extent) post there’s plenty of substance on both technical, management and corporate influences like the difference of styles guides vs agent instructions, binary size, compile time, Anthropic’s marketing and incentives, etc. It’s hard to miss.
Does anyone think that if Bun had been rewritten from Rust to Zig that a member of the Rust core team would have written a personal hit piece against Sumner (while pretending it isn’t a hit piece)? Probably not.
Kelley can write what he wants, but as the BDFL of a rising programming language, people are allowed to react if they don’t agree with the public image being portrayed by Zig.
Yeah, don't discount how powerful "marketing" is to management/executives, and also don't discount how absolutely ridiculously petty people can be, especially people who end up like CEOs and similar, requires a particular person. I can definitively see reason #1 and #3 from that to basically already set in stone that Bun had to be rewritten in Rust.
Maybe people were more interested in the agentic part more than the actual rationale for the port in the first place, because it was very disappointing from a technical standpoint.
Did we read the same article? I mean it wasn't talking about a specific line of code, but it had deep architecture details, rational for memory safety and bugs, agentic coding patterns for scale. It was full of substance, multiple times.
Why was it in their own words a real option? And why did they not go for it? This is the technical substance I'm looking for: an engineer explaining what options have been considered and what wanted and unwanted tradeoffs they present.
Also only mentioning figures for the platforms that saw an improvement is sketchy. "With ICU and code folding Windows and Linux get 20% smaller", what about macOS? Why did it not see the same gains? The fact that they don't mention it makes me think that they don't KNOW, and isn't confidence inspiring coming from the engineer who SHOULD know.
You can argue that that's a bad justification for not doing it, but that's a debate on the technical merits, not a claim that they didn't provide justification.
"Technical substance" simply requires that some technically substantive things are mentioned. Which was indeed the case.
If you write a blog post about "I switched from X to Y", I expect the WHY: the pros and cons of X, of Y, and of the alternatives that were considered and dismissed before considering Y.
This is more a blog post about how to use Fable to switch from X to Y, than it is about X or Y.
Instead, the first half of it solely consists of personal attacks.
It's insane that Ray Myers thinks that Anthropic did anything related to this port that requires holding them accountable; the fact that he used those words makes me want to prevent him from having any influence over AI policy.
Zig’s author, Andrew Kelley is out of line here.
> We made futile attempts to guide them towards better programming practices. There were a few exceptional heroes who did their very best in a dysfunctional company. You know who you are. But you can't stop a rising tide.
https://andrewkelley.me/post/my-thoughts-bun-rust-rewrite.ht...
So not only is Zig written by amateurs, but these amateurs also don’t know how to run a company?
Who is Andrew to say this, Oven got an exit. As far as their investors and owners are concerned that’s the only real reason to exist.
Assuming ( big assumption to be fair) all the early Bun employees got a fair amount of equity they’re all rich now. That’s a much better outcome than most startups.
At my first startup we had 6 day work weeks. I still remember staying up until 2 or 3am manually installing Postgres again and again. All we got was a paycheck. Although for me I went from a minimum wage earning college dropout to a 6 figure software engineer( at a new company).
As for actual coding… LLMs will always do better work in a well known stable language than something relatively new.
I had to give up on trying to get LLMs to write working Haxe code. Haxe is too niche for LLMs to handle.
I personally can’t stand Rust, it feels like it’s designed for machines to write. Zig is designed for humans. Outside of a 200k+ job offer you won’t see me learning Rust.
Zig is rather pleasant. I can imagine writing a side project with it.
Finally, my QA background is screaming in rage. You expect me to trust a project that you basically vibe coded in a week as a key part of my workflow?
You know it works because the automated tests ( which I guess you also vibe coded) pass ?
By that logic say I don’t like Rust, can I spend a few thousand in Fable tokens and ship DinnerRoll( Bun in D).
Is that enough to raise a VC round?
Say that louder for the people in the back, who still think that LLM companies don't influence the entire programming language and framework field, by merit of the fact that LLM's can only perform at scale after lots of training.
And when we reach the point where source code doesn't need to be read, said companies will vendor lock you even harder by marketing their own LLM-optimized language and framework, promising everything and the moon in terms of productivity gains. First class support was the reason they acquired Bun.
I'm trying to not let this affect my thoughts about Zig as a language but it's hard.
Even if the guy is a terrible manager this still comes across as a determined attempt to find something negative to say.
To me it’s telling how little focus there is on the technical merits of the rewrite from zig side. Anthropic claimed a bunch of victories and as best as I can tell nobody has even attempted to refute them.
If I was running a project and someone threw it into an LLM rewrite and it comes out with improvements and silence on downsides I’d be pretty worried and try to address that. Instead we’re talking about working hours somehow
I was saying that LLMs even worse at writing for the web than humans, and humans are pretty bad! I'm saying this as a web developer.
This, I don't think enough people pointed this out. We have been sold the "coding is solved" and "software engineering is over" shit by Anthropic folks for a while now. The discourse should have revolved around claude's capabilities and instead it became a Jared vs Andrew thing.
I think this is the most important line from this piece.
Incentives matter. The AI companies are incentivized to have us believe that LLMs are the new compiler. That’s ridiculous (a coding LLM is a very very leaky abstraction) but I hear coders, especially coders with poor fundamentals, say it all the time.
This entire AI period has been a study in marketing disguised as futurism.
I say this as one who uses and teaches AI. What fantastic, amazing, unreliable tools. Extraordinary in the right hands, but engines of cognitive and technical debt.
- Your AI code is probably as good as your human user's skills and attention:
Seems pretty likely they were shying from style guides because the AI use was itself sloppy. I'm not a big AI user but if I just ask a chat model for some code it will give it to me, then I have to go over it and fix the code for our check-style. Without deliberately aligning all your AI use to enforce it style is hard to maintain. Existing lack of style was a technical debt they didn't want to pay.
- The most popular language is probably the best language:
I suspect the amount of training data on Rust is several orders of magnitude greater than Zig. I suspect they could have gotten there simply asking the LLM to rewrite the Zig thing in Zig, however I'm betting LLMs write much better rust code so why not take the opportunity to move to a language that will get all-around better results.
- Technical bankruptcy is more favorable than paying technical debt:
These migrations we're seeing seem to point to a future where it's simply easier to burn a code-base to the ground, take the test suite and re-implement rather than actually pay large amounts of technical debt. I think this is a pattern that will come up more often with heavily AI written codebases that become untenably noodley, or brittle.
Now the Zig community is attacking one of the largest and best-known codebases ever built with the language. Anthropic’s motives are clearly promotional, but even so, I would not choose Zig for any project.
It is useful, you just have different goals in mind than the Zig leadership. Zig shared their detailed reasoning for that decision, which is mostly about the development and protection of the community
Zig’s response has been a serious mistake. The TypeScript team ported the TypeScript compiler and language service from TypeScript to Go for TypeScript 7.0. Did anyone interpret that as the team insulting TypeScript itself? I certainly did not.
What is more hurtful than somebody else making wrong religious choices?
That's just not fair!
Judging from internet posts and HN comments, many do.
Yes, “it could have been any other company”, but it wasn’t, it was this one. Had it been any other company, we’d be talking about that other company; because it was this one, we’re talking about this one.
But that's true only if one believe what they are putting out blindly. Why not just call it a bluff and move on rather than making a mountain out of molehill
This feels equivalent to saying you're not a real coder if you need a compiler to hold your hand. What, a human coder isn't enough?
Of course we're going to improve tools by building more tools on top of them. That's how we went from punch cards to assembly to high-level languages!
If they keep hiring developers and LLMs need huge procedural harnesses, then the hypocrisy is open for all to see. And worse for them, it probably means their business model is worth maybe 5-10x what Jetbrains is worth, not $1tn.
As for valuation, it's all a grift, always has been for anything hip in tech. SpaceX should've been in the $500b range and they have an actual rocket and working satellite constellations
And regarding SpaceX, SpaceX even without xAI didn't make a ton of money and it's business initiatives are super long horizon things. Moon bases won't be profitable for at least 10 years and Mars bases probably for 20+.
Also, even though they are behind, competition is moving. China caught their first rocket yesterday (and we know they can move fast), BlueOrigin is behind but they have the money to keep going. The EU and India will keep investing and developing as rockets are a core concern for both, at some point they will have reusable rockets.
These huge valuations for SpaceX are predicated on winner takes all mechanics, which are mostly software based. Many markets don't work like that since the cost to get another unit of revenue increases linearly with that unit. Not like software where extra copies and customers are basically free.
The thing I still think is wrong: why are Anthropic rewriting a Javascript runtime from Zig to Rust? Why not rewrite Claude Code itself in Rust (or Go or whatever, lots of options there) and drop Bun completely. That actually seems like an easier solution (rather than having to create a performant, correct Javascript runtime, just rewrite your CLI console app in something else) and the final result is better (smaller and faster) although likely not on the most critical axes for them.
A. making consumer end-user apps, basic enterprise applications (making end products)
B. making tooling, libraries, languages (making things people build on top of)
What is the "software engineering" that AI will replace? A? Or both A and B?
Just because people can get away with using AI to make A apps that are "good enough" or pass test suites, does NOT meant that therefore people can get away with doing all software engineering with AI. B products require a whole other level of quality, stability, and extensibility.
I'm not saying doing A with AI is a good idea either, I just think that it's a fallacy to say that because you can do A with AI, you can do B.
> Ray’s story: Faced with a legitimate challenge of memory bugs, there were several viable options. Management eagerly approved the Rust rewrite option because it was a great marketing opportunity to showcase their new Fable model, Anthropic already uses Rust, and Zig is openly against using Anthropic’s products.
Kinda makes sense. They also tried to make a C compiler earlier in the year. Idk what happened to that.
I guess it's an experiment without much downside for Anthropic, if it works use it to make a point about AI assisted coding - if it doesn't bun users will learn a costly lesson but who cares, it will just be another case study to make their product better.
That said, I think it'd be great to see this actually work out.
Yes, Andrew edited it. Diff here: https://github.com/andrewrk/andrewkelley.me/commit/8b86ac915...
There's no point. It's not doing the job DARPA's TRACTOR program is trying to do - translate C to safe Rust. I've used c2rust. It works, but what you get out is like compiler output, not something you can work on.
The Rust toolchain is a delight in comparison to Zig's, and the unsafe code only need be temporary until humans (or, gasp, AI) address each class of underlying issue.
This is a no-worse-off state to improve from.
While this may be slightly overstated, my take on this is that AI progress should have us upgrade our view of the human brain rather than the opposite.
Wrote about it the other day:
https://livingsystems.substack.com/p/ai-progress-should-upgr...
https://www.uber.com/us/en/blog/postgres-to-mysql-migration/
Another point of view is that, if AI wasn't available, pre-port Bun wouldn't have been such a total mess that even Fable couldn't unfuck it.
IOW, the Bun codebase was being vibed well before the port; if AI was not available, would Bun have been in such a poor state that a rewrite was even necessary?
In the meantime, most of us are just using whatever tools are at our disposal and minding our own business.
I'm using Rust as a placeholder for a language with excellent performance and safety characteristics. It may not be a good thing, but there's no way around it.
It will be sad if everyone buys Anthropic's hype, forget the basic engineering principles in this industry and think that AI solves every problem. Fortunately lots of people don't.
But what do I know, maybe your CTO bought this and now wants to fire half of the dev team and use Claude to convert your COBOL codebase to Rust...
> The piece about the migration process is very cool, with details that are reusable. No complaints, I think that’s the real contribution here. I particularly like the honesty in explaining that this was a port to unsafe Rust, allowing a literal file-by-file migration to minimize risk, paving the way for redesign in future steps. That’s a sensible move explained well.
There will be a group of programming languages that become the main choices, (Rust, Go, Typescript, C++, Java, C, Lisp and Haskell) for agentic coding, Zig was slightly too late to the game, the great LLM cutoff has happened.
Andrew is trying to fight the tsunami here with a paddle boat as his vision of Zig was conceived before LLM's landed on the scene and is likely unable to accept it.
We already know junior hiring an are down. And how many people are now excited to learn to code compared to 5years ago?
How many of those excited people are ACTUALLY learning to code and not just learning to prompt?
LLMs/agents will take over (or at least dominate) software dev even if they don’t get any better because humans will just get old and there’ll be no new humans who know how to do it.
People who were in the marketing data analysis (like sentiment analysis) - 5 minutes and they have a code that uses Hugging Face model suited for sentiment analysis, zero-shot classification, etc. No need to pay for expensive online services or expensive NLP software. It's here for free or $20 a month.
Still, it does not mean you will be able to code database engine with LLM, application server, rewrite Django in Rust, etc. So software engineers still will be needed to do ambitious, complicated stuff.
So, I kind of see it backwards, real skills, like knowing algorithms, understanding performance (including hardware stuff like processor caches, etc.) will become needed, as other, simpler jobs that needed only a "coding monkey" will be gone.
We no longer need to dig ditches manually, we have machines for that, but the purpose of the ditches is still planned by man.
Intuitively, Rust would perform worse because ownership is a different paradigm, while Zig is far more similar to things like C/C++. But I guess that's canceled out by the disparity in the language resource base.
And I think the only sensible backend languages when starting a new for-profit project is Python, Go, and Rust for 99% use-cases.
In other cases, third-party packages, tooling, integrations, and telemetry starts to suffer.
Specially if their community and their BDFL continues to be welcoming and fun to interact with.
Their 1.0 roadmap announcement is cool: https://youtu.be/dLPAqXi9In0
Here's most of the language in a single demo file: https://odin-lang.org/docs/demo/
My thoughts on the Bun Rust rewrite
https://news.ycombinator.com/item?id=48843352
Rewriting Bun in Rust
Life would be paradise if people were just good for each other. They are not though. So you need a system for that case. Rust is a system that fits the modern real world software development dynamics than Zig.
Anthropic does not need to tell me that much of software engineering is being re-written. In my opinion, the costs have crashed. I build commercial projects at 1/3rd my earlier costs. I started build everything I can in Rust and I am still doing that. My projects have only gotten more ambitious, latest being https://github.com/brainless/akar - a WIP, please don't scream at me.
Many folks have publicly said they want to keep AI agents away from their works. Good for them. I want to accelerate software engineering, something I have done passionately for 20 years, with all the agents I can use. And I make my own agents, constantly experimenting to push local llm based agents.
If engineers want to stay behind, good for them. Not everyone does. Andrew Kelly's post read like an attack, IMHO. But why care about me? I am just a farmer (https://www.instagram.com/curryhostel) who uses AI to now build ambitious software.
But that change does not mean my products will become popular. That is a lot beyond software. Also, the tooling is just barely 1.5 years old and people are already asking for world-changing results. All the while totally ignoring what indies are saying.
The fact that people’s personal experience using the tool don’t cohere with the impact the tool has had in the world to me doesn’t suggest a slippage between how long it takes for productivity multipliers to be felt, it suggests that these tools might actually be better at delivering the perception to the user (and where relevant, the user’s manager) of increased productivity while real productivity gains are lower, or maybe zero, or maybe negative in some cases.
I am a software engineer, most of my experiments are on GitHub. I would not have ventured into building the UI framework before LLMs.
And this is what bothers me - people are not looking at the generated software. Indies like us are experimenting like crazy. I live far outside the tech scene, in a small Himalayan village. But I resonate so much with the experiments, the methods, harness engineering and so many other topics. I see the benefits in how ambitious my projects are becoming.
I teach an online course on coding agents as a co-mentor. 600 young professionals join each month for a 2 week course. The joy of people, who did not know much technology, when they create a simple project management software by just typing English does not lie.
We used to write software in a very different manner. The entire mental paradigm has shifted. Many of my friends and acquaintances are on the fence, still! Some are internally giving up - unable to cope with this change. But the change is happening - the tooling is only going to get better.
Give it time. That is the opinion I hold.
And what do you think about coding agents in the next few years? Will we see a variation in agent capabilities? E.g. a company makes and distributes a specialized coding agent for CSS, or even serving up a kind of library that's language-agnostic, since they seem to be best at translation rather than creation?
Or that the gains are in niche applications (like the GP's) that don't translate at scale.
For the normal person, they now have more choice. To businesses it is an even more fierce competition. There is an illusion of productivity since everyone using LLMs can’t stop because their competitor is also moving faster with LLMs.
So everyone is so “productive” in “building” anything at the third of the cost, it also means that even the customers that the builders are selling to are also building their own solution themselves.
Customers turn into competitors faster and those in pure software are now making even less money. Except for companies in frontier AI, infrastructure and hardware.
I am sure you have a great story for your username and the blank HN profile too.
I commented on Mastodon[2] to point out to Kelley that it's dishonest to silently remove the accusation, as so many people were already talking about it, and it confuses the conversation if Kelley retroactively edits it, and he replied[3]:
> the false claim is in the bun blog post not mine. I only changed the text because it's easy to lazily argue against it. Please read more carefully. They are the ones being deceitful not me.
Loris Cro, Zig's VP of Community, gave a slightly clearer response[4]:
> Jarred's post has a section about what they "were already doing" to maintain their Zig codebase, which includes "24/7 fuzzing", which will make the average reader assume that the codebase has been fuzzed thoroughly, while in reality it has been for, what, 2 months before the rewrite?
Even then, I find it so bizarre that Loris thinks that if someone says, "We've been fuzzing Bun," and shows evidence of months of fuzzing, then that person is lying because "We've been fuzzing Bun" somehow implies something longer than two months.
The duration is irrelevant. If you say you've been fuzzing it and you've fixed bugs that your fuzzer found, then clearly you're fuzzing. The Zig team doesn't get to arbitrarily move the goalposts of what "fuzzing" means.
[0] https://news.ycombinator.com/item?id=48845652
[1] https://news.ycombinator.com/item?id=48854921
[2] https://m.mtlynch.io/@michael/116896188093796421
If you read the post again this sentence is not removed and Sumner did not refute that
If Sumner says today, "We do X," then Kelley can say, "Nine months ago, Sumner did not do X," and both can be correct. What Kelley can't do is say, "It's an outright fabrication that Sumner does X today," based on an observation from nine months ago.
It was just a marketing piece. It offered many data and pretty graphics but only that, no way to attest the veracity of it.
And this whole thing reeked of a publicity stunt. Show people you can use $$$ of tokens to vibe code a refactor. The headline is how great anthropic - bun's owner - is.
He complains about the lack of motivational blog post until after the merge, but a) they aren't obliged to do that (where are all the "it's free so you can't complain" people now?), and b) they gave plenty of motivation in HN comments, the rewrite PR, etc.
I don't like the idea of AI slop code either but it seems to work at least reasonably well for porting from one language to another.
Anthropic have lost their minds, and eventually a metric shit ton of money. Meanwhile, nobody uses Bun or Zig either. Rust continues to chug along very very slowly.
It's a good thing to point out these unspoken truths explicitly. As people internalize the norms that make it bad form, it becomes easy to skip the mental step of acknowledging the problem. Even internally. But that quiet acknowledgement is necessary to keep oneself sane. Without it, the best case is someone steers away without good reason, at worst it leads to experienced and expressed frustration that doesn't add up and can snowball into the wrong places.
The whole point of the borrow checker is to make it impossible to write wrong code. If Zig accepts bad code, but assumes people will have self-discipline to maintain it, how is that different from C?
C assumes good discipline, as well as C++. But it will happily accept bad code. So I'm not even sure what Zig is even improving on.
Rust was designed to answer this exact problem (among a few others of course).
So the argument "your code is fscking sheet" is very 1990's. In 2026 we need guarantees that we can't produce invalid code.
> In 2026 we need guarantees that we can't produce invalid code.
Rust doesn't provide either of those guarantees.
If I were to rephrase your sentiment for accuracy: Rust disallows certain coding patterns. Certain classes of bugs can only appear in those coding patterns.
IOW, Rust disallows $FOO which is a superset of "specific class of errors". This means that while Rust prevents specific bugs, as a side-effect it will also prevent some correct code.
Also it doesn't guarantee that the code is always 100% correct.
But I think this is the correct direction of programming language evolution.
An issue with Bun is that it interfaces with a C++ JS engine and it needs unsafe. In this case, the best practice is to write a safe binding to encapsulate this external dependency (that's why in Rust we have -sys crates with raw unsafe bindings, and other crates with a safe interface on top), and then write your business logic entirely in safe Rust
However, the Rust port of Bun didn't follow such best practices (perhaps with good SDD practices it could, not sure about that). The resulting code has literally thousands of unsafe blocks. It also contains plenty of UB. The port already costed hundreds of thousands of dollars. It's unclear if Mythos/Fable is able to refactor it further to remove unsafe usage without introducing further UB, and how much it will cost
(here It's important to note something. Rust UB is in some abstract sense harder to deal with than C or Zig UB, because it also needs to uphold the guarantees of safe Rust. If you get to write your business logic in safe Rust that's a good deal, but the price of that is that your unsafe code has extra responsibilities)
> how is that different from C?
Zig gives you far more memory and type safety than C and without a borrow checker and a complex generics system.
Zig also allows optional runtime checks (at the cost of runtime performance).
There is no better language between Rust and Zig because they have different tradeoffs that are better or worse in different scenarios. It is more like Rust vs C++ and Zig vs C.
The borrow checker prevents a set of errors from being possible, but it doesn't prevent bad code from being written.
Because a lot of mechanisms actually still have guards in runtime. And using .clone() on Rc/Arc is actually the idiomatic/preferred way of evading the borrow checker if we can't design the data structure in a different way.
It's a big difference between cases when you need to spend brain energy to find ways to "out-smart" the compiler, and spend brain energy to "fit into the proper set of assumptions" of a programming language.
This also helps to focus on the remaining things that could go wrong.
The integration of unit tests also lowers the barrier to just sprinkle some tests in, if you're unsure that you got an edge case right. Anf clippy (not stricly the language, but still kind of a core component) greaty helps to stay on the idiomatic track.
No silver bullet of course, but I never had so few runtime issues with any other programming language so far.
What logic bugs did you encounter the most?
edit: mobile typos
I've seen many people make this claim and it's wrong but also silly. How do you think type systems work?
I didn’t read further, this is just sensationalism at its crudest
Where did Anthropic say that they want to “end” software development. They make it more efficient, which could lead to less software developer.
How is this “campaigning to end software engineering”? It’s an exaggeration at best, dishonest and sensationalist at worst
There's like a trillion more examples you can pick from, as we all know it's been a core part of their marketing.
> It’s an exaggeration at best, dishonest and sensationalist at worst
It is quite literally what they're CEO keeps claiming over and over, it does not get more cut and dry than that.
https://www.entrepreneur.com/business-news/ai-ceo-says-softw...
https://xcancel.com/Vivek4real_/status/2074990159783768107
If you're selling a product and you're claiming that product will replace something, it's not unreasonable to claim that you want to end that thing.
https://digitalstrategy-ai.com/2026/01/23/claude-code-anthro...
> his engineering teams rarely write code from scratch anymore. The role has shifted from creation to orchestration. Engineers now operate as “conductors”—defining high-level problems, prompting AI systems to generate implementations, then reviewing and integrating outputs.
Well I have been working like that as well but sure as hell I still consider that to be software engineering. You won’t get anywhere if you try doing this without being a software engineer. At least not very far, see how far purely vibe coded applications can get.
Anthropic leadership, including CEO Dario Amodei and co-founder Boris Cherny, has declared that software engineering is dead or will become obsolete within 6 to 12 months due to AI automation.
Cherny states that at Anthropic, no code is manually written anymore, with engineers using Claude Code to generate 22–27 pull requests daily and AI agents operating in autonomous loops.
https://www.reddit.com/r/BlackboxAI_/comments/1qxhqry/anthro...
ding ding ding!
If nobody knows why the unsafe is required there's no way they'll be able to unwind it. If they can't unwind it then they're in a worse version of C (+ cargo).
It's practically impossible to write safe Rust when you are calling external libs written in C/C++, like they do for the Javascript engine.
The interesting part will be whether they can transform that "mechanical Rust" into something idiomatic. I'm waiting ...
I don't care what Anthropic says and what the CEOs buy, I care about my own output and the recent models give me 2x uplift easily, I'd say 10x in single digit percentage of the time and I know I'm not using them to their full potential. We're living in an era of mass produced software. You can still be an artisan in this era, but you have to be aware.