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.
The friction itself does not add value. The time spent thinking on the problem does. Friction should be minimized beyond the absolute bare minimum. Programming is a discipline where your workstation is already streamlined, and it is easy to forget where the friction is. Programming is done in a world of pure though, in a sense, so most of the friction already lives in your head, and it is difficult to distinguish effort wasted fighting friction from effort making real progress.
Consider the Wright brothers. They worked iteratively. When they wanted to design an airplane they moved from Ohio to a windy place with lots of loose sand (NC outer banks). Why? So that they could do test runs with good wind conditions (for an airplane that is barely able to fly this matters a lot) and crash with the least amount of damage. They rebuilt the airplane dozens and dozens of times and had a workshop tuned to their needs on location. They reduced friction wherever they could so that they got the most work done that they could with the least amount of distraction.
It seems that way, but that's not actually true. A fully greased-up brain would produce just incoherent nonsense decoupled from reality, because it would lack all constraints that would allow it to judge the value of an idea (i.e. how possible and useful it would be to implement in the real world). The friction comes from fitting your ideas into the real world.
>They reduced friction wherever they could so that they got the most work done that they could with the least amount of distraction.
They reduced unnecessary friction. They could have eliminated all friction by imagining a teleporter machine that can send you anywhere instantly and that runs on the hopes of children. But they still wanted the friction of unsuccessful attempts so they could actually build a plane that worked.
I would say that, within the Wright Brothers example, working with a battered, worn-out screwdriver is an example of friction (or, perhaps having to use a bit and brace instead of a power drill), but the act of building a new unsuccessful airplane iteration is not friction. Every build is asking physics for feedback on the design; every airplane build is just the same as running your code through the compiler. I wish I had a good word to distinguish this from friction. The closest thing I can imagine is how waste is defined in Lean Manufacturing, but keeping in mind that what you are manufacturing is Ideas and Software.
Concretely, If your only goal is to produce "software" then learning about design, planning, project management, testing etc is all unnecessary friction when you can just ask an LLM to "make it so"
Exactly. I don't have to write binary machine code directly, every zero and one artisanally crafted by hand, to have thought deeply for years about a how to solve a problem.
In fact, choosing the right level of abstraction is essential to my ability to solve the problem.
For most problems, the friction of writing binary code by hand is the wrong level.
And we're discovering that many important problems can be solved faster and with greater quality than can be achieved by dogmatically hand-writing every line of source code just for the friction.
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.
Both needs heat.
There really, truly, absolutely, 100% is no accounting for taste...
Let's first settle on the definition of vibecoding so that we're not miscommunicating over definitions. I'm using the one that seems the median definition nowadays: >95% of the code written by LLMs, <60% of the output code human-reviewed, meaning there's a large part of the codebase that no human ever reviews.
As you said it's about time invested in thinking about it, yes. But remember that even pre-AI >90% of software got never used, it was dead on arrival. Look up "success rate of software projects in business".
You can put lots of time into thinking and vibecode everything. You can put very little time into thinking and write by hand. Of course, vibecoding makes the former much more likely. But nothing about it is inherent to it.
Thinking of software from finance and derivatives pov really blew my mind. here’s the article, it has AI smell but it’s short and the mental model is good: https://newsletter.kentbeck.com/p/the-cost-yagni-was-never-a...
1. Same services provided using similar software stack, but maintained by fewer developers. I suspect this may hold for some sectors in the economy. Or
2. The Jevons case: similar # of developers maintaining a much bigger software stack that provides more services.
I might add:
2a: Similar but with lots of accidental complexity everywhere.
Probably we're heading towards some mix of the above? Depending on which application area you're talking about. Web dev is a lost cause, deeply-embedded won't see a big shake-up.
100%, you actually stated it correctly. It's not "I don't care unless you've written/reviewed everything by hand". If someone writes something by hand in an hour, including ideation, and puts it on Show HN, realistically it's almost certainly not going to be worth even looking at.
I've been running an app in prod for more than a year now, mostly vibecoded long before HN believed it was possible - HN only started believing this around Jan this year at the earliest. But nobody who uses it cares, or even notices, because it took a month to build. That's what matters, the amount of time and thought put into it. Of course it's true that vibecoded projects have a much lower median amount of time and thought put into it. But that's like Louisiana having a much lower median income than California, it's just a median, not an inherent characteristic of being a Louisianan vs a Californian, there are plenty of poorer Californians and richer Louisianans.
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.
That is such a miserably low bar
(I’m pretty sure both you and I would “know it when we see it”, but…)
EDIT: this is the one I was thinking of...
https://sinclairtarget.com/blog/2026/06/01/quality-in-the-ag...
But this is relevant too...
https://bersas.substack.com/p/zen-and-the-dance-of-generativ...
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).
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.
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?
Watch me.
I absolutely can and do. And pictures, and videos, and picture posts, and comics, and all image-format content.
If it wasn't worth creating with someone's brain, it is never ever worth my time to consume the prompt output.
Send me the prompt. I might look, if I'm bored.
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.
But this is the longer running discourse about AI code's cost / benefit. I keep nagging my work's AI community to show me the numbers, so far nobody has been able to show an increase in productivity, quality, customer satisfaction, or company profits.
The only gain is speed.
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.
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?
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.
I don't think anyone who actually uses zig thinks "it doesn't offer enough over C". Removing #define alone would have been worth it.
If you reach out to any project manager and pitch the idea to rewrite a whole app from scratch because you want to get rid of #define, first you will be laught out of the room and second they will reach out to HR to get a PIP going because whatever the hiring bar they used to hire a developer you clearly are not meeting it.
On the other hand, as a corporate backer for Zig, TigerBeetle is definitely a big deal.
But in terms of exemplary and imitable projects in the ecosystem I would think something like Ghostty is the safer label for "flagship".
Their success with this strategy isn’t portable to most other projects. I think they really need more traditional flagship projects that generalize to typical memory management use cases. The way the conversation keeps coming back to TigerBeetle as a success story isn’t helpful to anyone trying to evaluate the memory management angle.
> only works for very specific use cases.
It's not clear to me what you mean by this.
TigerBeetle calculates all the memory it needs at startup. It allocates that much memory once. It does not allocate memory dynamically.
This only works for very specific use cases, like a fixed server size where you know exactly how much memory you want to allocate to a process.
It’s not portable to general purpose computing, where it’s expected that apps aren’t allocating the maximum amount of memory they might use at startup. Their memory usage grows and shrinks as you open and close files or as your documents get longer.
> and the approach more commonly used in Rust (allocate wherever and whenever) is non-idiomatic in Zig
Allocating memory as needed isn’t a Rust-specific idiom. Most programming involves dynamic memory allocation.
I don’t think the Zig developers would go as far as saying Zig isn’t a good fit for dynamic memory allocation. If it was that simple this entire debacle could have been written off as “Bun requires dynamic memory allocation by nature, therefore Zig isn’t a good fit”. That’s not what Andrew Kelley is trying to say though.
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.
'plow through it's?? An LLM can definitedly fall into these traps!
Happened to me a few months ago, I couldn't believe that an LLM would generate a use-after-free in not-so-complex code but it did.. Newer LLM seems better now but buyer beware!
Warts and ancient quirks, I can kind of see, but in what way have LLMs solved the footguns?
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 don’t think this is a huge moat any more. Structuring Rust codebases in a modular way to keep incremental compile times down is common. The biggest complaint about it is from people who simply don’t like the structure and want to put everything into one big package, but that’s a stylistic choice.
I 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.
believe it or not it is generally easy to do this with zig with few modifications (WIP), and the team has said publically that they will be making this sort of thing a supported operation once the IR stabilizes post-1.0.
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.
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.
That’s what I’m saying. I hear “Better C” and my initial reaction is “what’s the point”. Like, why would you aim for “Worse C++”?
I mean, compile times. That’s fair.
The post starts off so cynical. I know a few people at anthropic and oai and the simplest explanation also matches my observations that they actually believe what they say. That agents will be doing the bulk of the programming in the not so distant future. They believe they themselves will be out of jobs at that point.
They aren't managing some message and trying to teach the anti AI folks a lesson.
Frequently, those alternative hypotheses are demonstrated to be true. For example, "emergence" as was researched and proclaimed by many labs, including places like OpenAI and Anthropic is due to using too few discrete steps in sampling a continuous phenomenon. See "Are Emergent Abilities of Large Language Models a Mirage?" [1] for example.
now THAT is cynical
> They aren't managing some message and trying to teach the anti AI folks a lesson.
Unless you know the senior execs in charge of marketing at these companies I don't know how you can make that assertion. I believe that a lot of the folks at these companies earnestly believe in the work they are doing. But a belief held by software engineers is not automatically shared by the marketing department, nor by senior execs.
"Anthropic is a giant company with a lot at stake and will seek to capitalize on any marketing opportunity" doesn't strike me as cynical so much as a statement of fact.
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.
First off, you seem to be under the impression I'm a rust hater. Noting could be further from the truth. Rust is easily my favorite language at this point, I reach for it for basically everything (except quick scripts). While I do like a lot of zig's philosophy, I think at the end of the day the empirical evidence is overwhelming that manual memory management isn't sufficient.
> What's your point, that if we can't do everything perfectly in one step we can't do it at all?
My point is exactly what I initially said: you typically aren't much closer to a (mostly) safe rust codebase if you've done a line by line port to (partially unsafe) rust than you were to start with. Getting to safe rust is very likely to require substantial refactors either way. This doesn't mean you shouldn't do it (on it's own), but it does mean that the bun team's strategy/assumptions are more questionable than they appear to realize.
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!)
> 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.
Is quite a hell of a statement, when memory management issues are highly nonlocal and need some careful design upfront in order for you to nail it.
Unsafe isn't something that you can gradually clean up. Even one single flawed usage of unsafe (an ill-assumed invariant) can poison the whole program in scary ways, and might require a total refactor of your codebase to fix it.
So if I use Zig, I need to do all of that perfectly from day one and I don't get any help from static analysis to do it. Or else I've poisoned my whole program in scary ways and will require a total refactor where I still won't have any help and once again can't make a single mistake.
> [what you just wrote]
So they gained nothing from a Rust rewrite, except introducing more bugs into their shit codebase.
Can you point to an equal number of issue tracker tickets showing novel bugs or regressions in the canary build?
The difference is that in Rust you get strong guarantees for everything that is not inside of unsafe and clearly demarcated areas where things might go wrong. Even if you never eliminate a single unsafe block, the clear demarcation is valuable as an artifact in its own right.
EDIT: You can't be serious people. Rust unsafe is safer than C, if for nothing else, for knowing which pointers are aliasable.
And how does Miri help solve this issue?
Are LLMs better at writing Rust than Zig? I'd assume so, there's way more Rust open source code than Zig. And if so, that's a very solid reason to switch IMO.
> 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 utility, enrichment, or pleasure are reached a lot faster.
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.
and the rust version has been live in claude code since june 17th.
It’s inaccurate to call it a rewrite. It’s more a transliteration - it matches the original Zig almost exactly but the syntax is different.
And yeah, unsafe blocks anywhere that rust would have complained
So it’s highly likely that the “rewrite” is exactly as reliable as the original.
(It sure feels like this was done for Anthropic marketing reasons, the more I think about it.)
They’ve just found a way to explore that logical fallacy even faster.
Because most projects are abandoned within months. Why should they be any different in that respect?
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...
Maintenance of the zig code was abandoned, while the port continued in the same repo, and it's unlikely any work on the zig branch will keep momentum. So yes it forked, but more in the fork+exec sense (or maybe just exec, the analogy's not that great).
> We became increasingly horrified at the programming practices we saw in Bun's codebase. Hacks on top of hacks. Abuse of assertions. Most of all, recklessly speeding past feature after feature with very little time taken for reflection and elimination of bugs and technical debt.
Just "1MLOC JavaScriptCore wrapper" is enough to figure out why.
src/ 143k
lib/ 127k
test/ 716k
deps/v8/ 3.6M
Rel: https://www.joelonsoftware.com/2000/04/06/things-you-should-...
Making software projects successful has always been about a lot more than just writing code. People have been "rewriting code from scratch" successfully even before LLMs. We just don't tend to call it that. We call it "cloning", "competition", "copy", "alternative-to", "reverse-engineering", "x-written-in-language-y", etc.
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.
It's worse, and I say this as an avid Rust fan and programmer. Try Miri with the new Bun project. It's currently blowing up. The Rust compiler's non-unsafe aliasing rules still need to hold during unsafe, which are far more complex than writing correct Zig code. That's the trade-off about Rust: The compiler has a ton of clever proofs for safe code, but if you're on your own, you'll have to do the work yourself.
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.
You think more amazing than what was made without LLM?
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.
Another definition: Rust is a lang to "Run fast and low-level software/firmware, with nicer tools, features, and syntax than the other langs which can do this"!
Obviously, the value proposition you find in this case depends on the subjective nature of that regarding rust vs zig!
(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 wonder if new version of Bun has the same emotional values in Jarred's mind, I mean he did write it by hand and struggled for a long time and invested a lot of energy.
Meanwhile the rust rewrite just magically appeared to replace it.
Which one is more valuable for a person? High Effort or low effort?
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_...
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…
Rust might be the right choice for Discord, I've no idea about that, but the problem is that the blog post lives on and influences people to this day.
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.
Unsafe in theory in a transliteration is only as unsafe as the original Zig was, which makes it a perfectly reasonable place to land as a transition point in a way that introducing large numbers of allocations simply isn't.
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.
Because we have a near infinite number of artificial monkeys figuratively typing at a computer keyboard and, once in a while, they spout out something that looks like an acceptable program.
But it's not acceptable: it's sloppy-pasta.
> Because value of a project is not in the code produced. It's in the amount of battle-testing that code has seen.
Yeah. I don't know if we live in the same world as some other HNers: I pay not one but three AI subscriptions: Google (through Google Workspace), Open AI and Anthropic. I'm switching from Claude Code to pi.dev atm.
I'm using LLMs daily. The person next to me too.
LLMs produce shit code. Pure unadulterated shit.
They're extremely useful for many things, including finding bugs. But, to me, they simply suck at fixing them. They write horrible, verbose, code full of bogus assertions and cases that are not handled or not handled correctly.
I do verify the output they produce: the number of time it "works" but I look at the code and see sheer horrors and say stuff like this: "wait, if you replace A by B like you suggest, shouldn't thing X that A makes be done too?". (it's a rethorical question: I know I'm right).
"good catch".
No. It's not a good catch. It's a totally obvious catch that any programmer who's been in this since more a few years (a few decades for me) would catch instantly.
Now if there's one area were they're semi okay'ish is for porting code from one language to another. At least you get a base to start from: if you're lucky. And I suspect it's only looks good if you don't know much about the target language.
Also don't be fooled: we're talking about a company with tens of billions investments that fully knows AI is not enough. You can be sure there are countless programmers fixing, behind the scene, the sheer mess that their AI (with unlimited budget btw) is creating. And then they pretend it's a 100% automated AI rewrite.
AI is not only definitely not enough: it's useful for finding bugs, it's a good rubber duck, but the more and more time passes, the more I'm appalled by the shit code it produces and by the errors they make all the time.
If I wanted to be facetious I'd say that at least we're already --how things moves fast-- long past the point were the kool-aid drinkers explain to us that these thing are intelligent.
It's summer 2026 and, as I type this, the SOTA models all suck at writing code.
Am I still deep into it? Sure am. For basically everything but coding (finding bugs, documentation, translation, generating assets, automating dumb stuff, ...).
Oh well, going back to pi.dev facepalming myself and rolling eyes. I know it's going to be "good".
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?
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).
It's not better, it's worse given the average bear's assumption about a rust project.
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.
I think it is worse than that, the comments from people in threads about this suggest that this is an attitude that is creeping into the community. They may not be a majority, but if kinder souls decide to leave for a more welcoming community, the remainder will be more concentrated.
Sigh, there definitely an attitude creeping into the community and it's a huge turn off unfortunately.
Similar to Go and Chess, AI might make “programming for beauty” more accessible and popular. However it will almost certainly make the act of writing “code for money” much less valuable, which means many people will stop getting paid exorbitant sums to do what they love.
Personally what I loved was never the typing characters or optimizing algorithms; building is better than ever. But I really empathize with those who loved the craft of code golf, algorithms, literate programming, the elegance of micro structure of programs, etc. and who see their world under threat.
I love all of those things but don't feel threatened by AI. I do weird microcontroller things, I have dweets on https://beta.dwitter.net I have a website for making animations using 50 characters of a custom stack expression code. Algorithms, code golf, asm, inventing instruction sets, working on my own 8 bit cpu design, all that stuff is what I choose to do with my time.
I don't feel like it is in conflict with AI generated code. There's still plenty of uninteresting code that it can do.
I see some people disliking AI because they like solving problems, which I also don't really relate to, because AI presents entirely new classes of problems.
I'm not sure how much of this is just dependent on what kind of person you are, I find it quite amusing to see the ways in which LLMs get the wrong end of the stick and find it fascinating to analyse and counter the things that lead it to go off the rails. Some people seem to have the same experiences but completely different emotional responses.
I have made things with AI that I could not have made without using it, but at the same time AI could absolutely not have produced it without me directing what needed to be done.
I think the animosity to AI is more complex. There's combinations of anger about wealth disparity, a loss of trust, another of Sagan's great demotions, and this weird anticapitalist embracing of a hypercapitalist notion of Intellectual property.
Adding to this is, I suspect a few actors spending money to muddy the waters, from the Russian government, to the discovery institute, to people who just seem to like the sound of their own voice.
Keep responding kindly, respectfully, without assuming you know the internal thoughts of others, and you can influence things in a healthier direction.
Possibly the thing that will determine the long term survivability of each will be the respective attitudes of dang compared to Andrew. Putting out flare ups may be a fairly thankless and unending job but it probably is more protective than pouring gasolene over them.
Maybe one day dang will pop and it will all come out in a spectacular rage.
Given the context, you mean Rust? Nothing against Rust folks but I wouldn't really call it more welcoming community.
What Bun did here is basically a sabotage of Zig's reputation. Andrew's original post might not have been the best, but the rewritten version is fine, and I completely understand where he's coming from.
It's not the first. He recently called GitHub employees "monkeys".
> What Bun did here is basically a sabotage of Zig's reputation
How?
This attitude is so precious to me - "Sorry guys, you can't criticize my criticism."
> What Bun did here is basically a sabotage of Zig's reputation
I don't even have any words for how silly this take is. If Zig's reputation was so poor that Bun migrating to Rust caused this kerfuffle, then Bun isn't the issue.
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.
By writing shit code, then claiming they had to port it to Rust to fix it, when the entire problem all along was their SHIT CODE, not the language.
Just the fact these people have auto-ported their code from one language to another twice now shows they have zero clue how to develop software.
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.
(The one reference I found to Rust’s compile times is them talking about how they had to split their Rust rewrite into 100 crates. A plain reading of this is the opposite of what you’re saying: they’re pointing out that Rust’s compile times are slower, but that this wasn’t an overriding negative.)
(Surely a relatively bland technical criticism of Zig - one that gets couched with praise - does not count as “a big fuss.”)
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.)
Others have pointed to some plausible technical benefits from the port, namely that it forces an enumeration of unsafe code boundaries. There's probably something to that, but the big idea is that Anthropic bet that its models could do a big job, and they needed to both demonstrate that and make hay of it. Everything aligned. They did the port. The artisans might call it slop, but it runs, they did it like 2 weeks, and they stuck it to the guy that shuns AI.
If you're the type of manager who picks farming out work to a body shop with 100 unskilled workers instead of hiring 2 legitimate FTEs, then this is speaking your language.
This is not how professionals behave in a profession.
Decorum actually matters.
Anthropic is doing bad stuff. They clearly have a broken internal engineering culture. Hence I don't use their products. But I expect to see this laid out in a structured argumentation that doesn't go after people and their personalities.
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.
For context, I'm using Codex and have no interest in either Zig or Rust, so just observing this drama from the sidelines.
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.
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.
That means at least from their POV what's already available is not enough or not good enough, and if they're correct then the companies making the models can "artificially" inflate a language's representation.
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.
That's not possible. If it were, you'd just fix the memory bugs directly in the original language.
Your best bet is to have a translation littered with unsafe blocks, so you still have to do the work of nailing down the specifics to make them safe. There's no magic "unsafe language" -> "safe Rust" pipeline, even with GenAI.
Rust is like the instructor demanding that you build your house up to the national code, down to the choice of nail for your floor board. Your house will be perfect, but building it is extremely difficult and high-friction. In many cases this is unnecessary.
"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.
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.
Except it is. The people using it told us.
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.
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?
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.
Gossip and hearsay; the "grapevine".
Besides, what does it matter how a language user does business?
> 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.
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.
At the same time, TigerBeetle can do this because it’s solving a specific shape of problem that’s amenable to that allocation strategy. Binding a third-party runtime written in C++ (TMU, this is what Bun is) is a pretty differently shaped problem that doesn’t easily admit that style.
In other words, discipline isn’t always enough (although you do certainly need it). Sometimes the shape of the problem makes environmental constraints (like the kind Rust offers) important.
- 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.
Edit to add: I'm unsure where assembly would sit in this analogy. Skateboard? Monocycle? Perhaps ice skates.
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.
> For context, I'm using Codex and have no interest in either Zig or Rust, so just observing this drama from the sidelines.
The latter part of the post is much less about Anthropic and more about AI coding in general so I’d say it’s still very relevant to your interests.
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? ;)
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.
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.
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.
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.
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.
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.
He said “there’s just one thing that would improve this” and hit the delete button.
That intervention saved me, and everyone I was working with, from a lot of unnecessary stress.
Venting is great - get it out of your system. Then take a deep breath, go for a walk, and then decide what to do.
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.
like linus lol
i hate marketing pr speak when it comes to technical things.
save that for the non technical customers
In what world do you think they have to justify a rewrite to anyone outside their company? Bizarre mentality.
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?
The Bun Rust port was irresponsible and unprofessional, merging a million lines of unreviewed code while gaslighting the community, relentlessly casting shade on Zig while pretending to be neutral and objective. The Bun rewrite was not just bad engineering, but also (one might say "stinky") management and community relations.
It's no wonder the author of Zig blew up emotionally - which was also unprofessional but at least it was honest and human, unlike Bun's author.
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.
And he didn't "expose" anything but gossip.
The people selling shovels are the ones building data centers and energy. Tokens are the "gold".
Like build times: they rewrote the Zig compiler to improve them, but Rust build times are typically much slower. Why no discussion of that at all?
Bun wants to ship new features ASAP (a shell lang, sqlite/pg client, etc), so they'd really want stuff like memory management out of the way. Zig forces you to think and deal with memory management, lifetimes, etc. Rust is just a better fit like w `Drop`, and Zig explicitly won't add `Drop` or anything similar.
Just like I wouldn't write a SQL database in Python, Zig is not the right tool for Bun. So there isn't really anything that "should be solved in Zig canonically". I'd say it's more in how Jarred want the project to move forward. Move fast and break things.
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.
They hired them because they already agreed with them. Reminds me of that Noam Chomsky quote during an interview:
> Marr: “How can you know I’m self-censoring?”
> Chomsky: “I’m not saying you’re self-censoring. I’m sure you believe everything you say. But what I’m saying is if you believed something different you wouldn’t be sitting where you’re sitting.”
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.
Why is just a wrapper type "less ergonomic"? Everybody does that all the time in every language. And then if you can convince me it is less "ergonomic": why does it matter if it solves the problem? And that is considering humans write the code manually. Why does it matter if agents write the code? This makes no sense.
> And that is considering humans write the code manually. Why does it matter if agents write the code? This makes no sense.
Because the particular form of non-ergonomic code that is demonstrated here amounts to a quadrupling of tokens. That's a substantial hit to the context window for safety that isn't even statically enforced.
"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.
IMO all the technical arguments and attacks are post-rationalization; different orgs, different contexts, different goals.
I think Kelley saw this, but couldn't resist muddying his point. I give him a pass. The rant [0] is too much, but the addendum about moving on is healthy, and I'd rather the BDFL be too spicy than not spicy enough.
[0]: https://andrewkelley.me/post/my-thoughts-bun-rust-rewrite.ht...
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 want to emphatically endorse this statement.
This is where the human workload will shift to: making good decisions... understanding why one path is preferred over another. And collaborating and communicating in constructive ways. More to the point, humans excel at being able to recognize when a chosen path is no longer fruitful, or where a conversation devolves into the unproductive.
We are constantly making decisions based on tradeoffs. We choose one approach over another, not so much because our chosen path is obviously superior, but because the peril on our chosen path is preferential to the peril on a different path.
I have used ai to great utility in my design process, to help me understand the tradeoffs within any given endeavor, greatly helping in choosing which path to take.
Thus far, I haven't seen an AI which can unilaterally be relied up on to always effect "good judgement" for the work it is tasked with completing.
But once good judgement, and the correct path, is codified in markdown files, ai can be exceedingly efficient in carrying it out.
Instead, the first half of it solely consists of personal attacks.
I'm trying to not let this affect my thoughts about Zig as a language but it's hard.
> Views are my own. I have no history with Zig. I’ve never spoken to Andrew Kelley
There are better primary sources to explain what ZSF is trying to achieve with its AI stance. Kelley's rant [0] was a bit much but the ZSF AI Policy [1] and Kelley's interview on it [2] are interesting and informative.
[0]: https://andrewkelley.me/post/my-thoughts-bun-rust-rewrite.ht...
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.
Probably. Likely would work with sub fable class model too.
> Is that enough to raise a VC round?
Doubtful. Think this move only works for someone with an existing product and following
So what you’re saying is actually build it, get it in the hands of end users and then find co-founder who does nothing but call his VC friends.
Maybe this co founder will be merciful enough to let me keep a 5% stake. Although in all seriousness, given Oven sold for ( Google AI estimate) hundred of millions that would still be more money than I’d ever need.
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.
https://github.com/oven-sh/bun/blob/bun-v1.1.42/src/bundler/...
My take is they vibe coded too close to the sun
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.
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.
Do you think this gives your claim extra merit? You understand it does the opposite, right?
What it actually achieves is that it makes you look like you're raging against the dying of the light, in utter and complete futility.
Yes, LLMs are especially good at the web stack, given that training data is overwhelmed with enormous volumes of such data. It is the one realm that has been completely obsoleted by modern AI, while a few other realms at least have some resistance.
Banger of a quote that one.
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
There is a lot of discussion about the exact tone and phrasing, etc, of Andrew's post. There's something there - we expect perfectly composed writing, never getting emotional, never saying how we actually feel about a specific individual's behaviour. Meanwhile, in private, we often let those emotions fly, name names, etc.
I think Andrew gave us an actual look into how he feels about Jarred -- ambivalent, largely.
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.
so weird people are not commenting on this.
it's like.. I dunno, rewrite linux in rust, because bun uses glibc, this will somehow make it better, so claude code somehow can run better?
hell, start with UEFI.
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.
I don't think this statement has the effect you want it to have. You're not laying out the experience you're speaking from. You're just setting it up so that no matter how reasonable the next thing you say is, it will appear maximally arrogant and condescending.
> 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...
In all my professional carrier so far, a full rewrite without reason is a recipe for disaster, see
https://www.joelonsoftware.com/2000/04/06/things-you-should-...
This Joel Sposky article is always my northstar when I have such "temptations". My 2 cents
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.
That requires some proof, because the trend is that users of A apps dislike the lack of engineering that comes with AI involvement.
> 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.
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...
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.
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.
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.
Had I given my wallet to the thief, this controversy (me getting stabbed) might never have happened.
This 100% was a way to getting back at Zig for not allowing their parent company's product, and a marketing move for Fable.
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.
No because Go and Typescript have wildly different use cases, and they explained in details the rationale for migrating the compiler, and why Go versus Rust. Their rationale makes sense, and did not throw Typescript under the bus (obviously).
What is more hurtful than somebody else making wrong religious choices?
That's just not fair!
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.
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.
You really need to escape the Zig vs Rust language wars bubble to get a real read on what Bun was doing.
They started by attempting a more direct translation. Not quite transliteration but close. At this stage they wanted to bootstrap the codebase into Rust as quickly as possible using parallel agent sessions, which requires minimizing the number of refactors that cut across the codebase. After it was bootstrapped into Rust they continued on the rewrite to take advantage of Rust’s features.
The anti-Rust side has been clinging to that first step as evidence that it’s all broken, ignoring the fact that it was an intermediate step.
The “unsafe” part is also confusing a lot of non-Rust devs who don’t understand that unsafe is used in cases of crossing FFI boundaries, which Bun does a lot of by nature
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.
Because that's what it really appears to be about, preserving a rich man family's legacy so his children can live for another few generations before they over populate and humanity repeats the cycle of indefinite war, hoarding of resources, and killing to have more for yourself. I guess every rich, powerful generation though doesn't think that future will come now, so they keep manipulating their way to extracting more and more from people and stealing their way to the top.
When a majority of the population is sick, naive, and overstimulated its not hard to convince them with your propaganda that that you are on their side and that the sacrifices they make for your power are worth it. of course they don't see how their life spans, their deaths, etc were for you cause and not theirs.
- 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.
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.
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.
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...
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/
And the reason is not technical. Technically, it is a great language. Legally, it feels risky to most.
Kotlin is a fully JVM compatible language. Java is catching up to it in some points (Project Loom has made multithreading in Java almost as pleasant as coroutines in Kotlin), but the experience in writing DSLs, code with lambdas, the brevity afforded by Kotlin makes it more pleasant than java. It's also the default recommended language for Spring/Spring Boot now, that is probably the largest JVM API backend project that ends up being used by default.
The benefits you get are:
* Probably the most stable platform you're ever going to get: the JVM is rock solid and does not require tuning honestly, unless you're trying to get a free few percents of performance. Your shitty SaaS startup doesn't need to do that.
* Probably the most performant JIT in the world. Python isn't nearly close, and Go is close by. Except that you get a good GC with the JVM. Or rather multiple GCs depending on what you really want: throughput/low pauses/etc.
* The packages are truly a massive thing. The APIs aren't always perfect, but behind python & js, it's probably the most fully fledged option.
* Publishing modules doesn't suck.
* Having to carry a jar around does suck a bit, but fat jars solve the problem, and if you're serious in your work, you can just GraalVM it and you have an AOT compiled executable that works great.
Negatives:
* It's java, man. It's still the same verbose beast. Doing low allocation work is a bit hard. Kotlin makes it better. Kotlin also has kotlin multiplatform with a large and growing API surface, and is probably one of the most pleasant multiplatform options, allowing you to delegate to any platform code you want.
* You're never getting a tiny 5MB executable. If startup time is an issue, work hard on GraalVM.
It was just a marketing piece. It offered many data and pretty graphics but only that, no way to attest the veracity of 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.
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.
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.
Yet, I've never seen those language creators blame anyone else. I don't recall Bjarne Stroustrup lashing out at people migrating from C++ to Java, Rust, or anything else.
Maybe humility is just a generational thing.
Isn't it a case of "SVN trying to be CVS done right", as Linus Torvalds famously explained during his talk about Git at Google: SVN was doomed from the start because it's not possible to do CVS right.
Is this Typescript Zig any good? (don't know anything about it) Is it even worth porting to another language?
And why not an entirely new project? Ain't it an admission of failure of LLMs at writing new code? (porting ain't the same thing at all as writing a new project)
No dig at Zig: I just want to know if it's not yet another turd of the extremely turdy JS ecosystem.
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.
4% is a lot in my world.
The interesting part will be whether they can transform that "mechanical Rust" into something idiomatic. I'm waiting ...
ding ding ding!
My thoughts on the Bun Rust rewrite
https://news.ycombinator.com/item?id=48843352
Rewriting Bun in Rust
Makes me glad I still write C!
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.
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.
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.
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.
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)
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.
> 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.
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...
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.