Definitely agree with this article.<p>At Netflix, I lead the Go language guild. We've been seen increasing reports of users finding their AI agents writing better Go code than other languages, and increasing reports of projects favouring Go over other languages.<p>Two additional notes I'll add:<p>- Go has _great_ resources on writing good Go code, including treasure troves at <a href="https://go.dev/doc/effective_go" rel="nofollow">https://go.dev/doc/effective_go</a> and <a href="https://google.github.io/styleguide/go/" rel="nofollow">https://google.github.io/styleguide/go/</a>. edit: Sorry, I forgot to add: we give these resources to AI agents and they use them to produce even better Go code.<p>- For a language team, Go is a dream. The `go fix` tooling, AST/SSA packages, ease of reading and writing `go.mod` (go mod edit, etc), and various other "platform"-y features make modifying Go code at scale way easier than other languages.
Uber reported that their Go code has quantitatively more concurrency bugs than code in other languages, and while to me it seems obvious from looking at Go's concurrency model, this is backed by actual data. Is there any quantitative data to back the claim that Go is better in an LLM based workflow than another popular language?
Matches my experience as well. Go fans have conflated "can easily make something concurrent" with "does concurrency well." Go's primitives for concurrency should almost never be used directly and Engineers below a certain skill level shouldn't be allowed to use them directly ever for long running production code.<p>As another example, Go still has not yielded a correct implementation of Raft or Paxos while there are dozens in Java, C++, and Rust. Antithesis found some more bugs in HashiCorp's Raft implementation recently[0]. I'm sure etcd still has some kicking around.<p>Maybe this is a "don't throw the baby out with the bath water' problem but the general evolution of Go has been lackluster. I reach for Rust, Zig, and modern Java instead depending on the specific needs and constraints.<p>0 - <a href="https://antithesis.com/blog/2026/finding-bugs-in-raft-implementations/" rel="nofollow">https://antithesis.com/blog/2026/finding-bugs-in-raft-implem...</a>
The "world" runs on Kubernetes which is using Raft: <a href="https://pkg.go.dev/go.etcd.io/etcd/raft/v3" rel="nofollow">https://pkg.go.dev/go.etcd.io/etcd/raft/v3</a><p>Are you saying that this implementation is wrong?<p>"This Raft library is stable and feature complete. As of 2016, it is the most widely used Raft library in production, serving tens of thousands clusters each day. It powers distributed systems such as etcd, Kubernetes, Docker Swarm, Cloud Foundry Diego, CockroachDB, TiDB, Project Calico, Flannel, Hyperledger and more."<p>One of the most popular distributed DB is Cockroach which is written in go and also uses Raft: <a href="https://github.com/cockroachdb/cockroach/tree/master/pkg/raft" rel="nofollow">https://github.com/cockroachdb/cockroach/tree/master/pkg/raf...</a>
etcd has had numerous liveness and safety bugs, with one happening as recently as December of 2025. Would you consider that a correct implementation?<p>You may be interested in knowing that the largest managed Kubernetes service in the world (AWS EKS) ripped out etcd for in favor of their homegrown consensus service for large scale EKS clusters: <a href="https://aws.amazon.com/blogs/containers/under-the-hood-amazon-eks-ultra-scale-clusters/" rel="nofollow">https://aws.amazon.com/blogs/containers/under-the-hood-amazo...</a>
etcd is some of the most amateur code I've ever seen, despite being one of the oldest and presumably most mature "infrastructure" projects written in Go.<p>goBGP is arguably even worse.<p>I don't have a third place in mind that's even worth mentioning relative to these two.
I'd like to know what you base your statement on that the Raft implementations in etcd or CockroachDB are incorrect. Your original paper does not mention those implementations, so where does that claim come from?
Having run a fleet of 100s of etcd clusters for 10000s of rps, and the fact that upstream runs tests similar to antithesis and recently partnered with antithesis [0], and jepsen has tested it long ago as well [1]. Etcd's raft algorithm is fine. Someone even did a TLA+ proof on it in the last couple years[2]. Yes there was a correctness issue a few years ago but otherwise the person you're replying to doesn't know what they're talking about. Also those bugs have nothing to do with the raft implementation, but instead the state machine implemented on top.<p>0: <a href="https://etcd.io/blog/2025/autonomus_testing_with_antithesis/" rel="nofollow">https://etcd.io/blog/2025/autonomus_testing_with_antithesis/</a><p>1: <a href="https://jepsen.io/analyses/etcd-3.4.3" rel="nofollow">https://jepsen.io/analyses/etcd-3.4.3</a><p>2: <a href="https://github.com/etcd-io/raft/pull/113" rel="nofollow">https://github.com/etcd-io/raft/pull/113</a>
Sorry to pile on, but yeah, I wanted to use etcd during 2021 and 2022, around v3.5, but etcd had serious issues including silent data corruption. If you are curious, ask gemini flash "there were a number of etcd releases years ago where it seems a new wave of developers came in and started breaking everything"
Surely the King is doing it, so that must be the correct way. Look, the King even wears clothes and is totally not naked at all.<p>That the world runs on Kubernetes is no qualitative statement about the correctness of its Raft implementation. You can say that it's clearly good enough to not matter most of the time, but that is a different statement.
No matter who you look at, they're just cooking with gas like you do, and they can make mistakes in just the same way.<p>Now; I'm only attacking your argument. I do neither know nor particularly care about the correctness of that implementation itself. There's been better refutations of the claim you replied to in other answers anyway.
Now there's three of them <a href="https://github.com/hashicorp/raft" rel="nofollow">https://github.com/hashicorp/raft</a>
That's not remotely what he's saying at all.
> As another example, Go still has not yielded a correct implementation of Raft or Paxos<p>> are you saying this implementation is wrong?<p>> That's not remotely what he's saying at all.<p>I'm v confused by this thread
I don't care for Go myself (especially its concurrency model, which is a total dinosaur in a world where we have structured concurrency) so I'm not saying this to support my favourite language, but:<p>That is literally what the comment says.
Thank you. I don't know why this is so complicated.
> Go is bad so "I reach for Rust, Zig..."<p>I hope my every competitor will take your advice to heart, as one of our competitors did when they read that "Go is not a memory safe language", so they wrote a blog about how they are porting to Rust. While our team was moving fast and using those "primitives that should almost never be used" around our long running production code base with success.<p>Some time has passed and now their company does not exist anymore and we have a lot of their clients.<p>Thank you!
Where would one ever read that Go is not memory safe? That's just a false claim, and anyone believing it would have probably gone out of business regardless of choice of programming language.
Perhaps that company failed <i>because it chose to port things to Rust</i> and not because of Rust itself? Or any other number of reasons that survivorship bias might be mistaking.
What domain is your company in?
You seem to be implying, based on the rest of the thread, that Go has some sort of special defect that keeps it from implementing Raft correctly. But the "special defect" that Go has is that it in practice implements the same primitives in practice that almost every other mainstream language does, rather than implementing some sort of super-safe concurrency primitive like Erlang or Pony, or being immutable like Haskell. And even those things are of only marginal utility for Raft, preventing some local issues, but the hard part of Raft is more in the logic and the communication, for which none of these languages have any sort of special support or anything that will particularly help you get it right. Of the languages you listed only Rust provides any assistence over the standard mainstream languages, and like I said, in the context of Raft, it is not necessarily all that helpful.<p>If you want to see something that could potentially impact Raft's correctness, search the last couple of days of the HN front page for choreographic languages [1]. But none of these are even remotely mainstream enough to depend on for anything. Nor do I know if anyone in these languages has implemented Raft. A rather good test case for them, if any of them are looking. That's something that could actually help a Raft implementation's correctness, not just fiddle around the edges of local concurrency issues.<p>[1]: <a href="https://hn.algolia.com/?dateRange=all&page=0&prefix=true&query=choreogra&sort=byDate&type=story" rel="nofollow">https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...</a>
Also, wasn’t this about concurrency? You could, if you really wanted, write a paxos or raft implementation with no concurrency.
That does not seem like a fair/accurate reference?<p>The antithesis author states:<p><pre><code> "we’ve found bugs in every Raft implementation we’ve tested, including HashiCorp Raft, Aeron Cluster, OpenRaft, and MicroRaft"</code></pre>
Java has so many excellent concurrency containers, plus robust 3rd-party containers like JCTools. It puzzles me why Go communities do not offer such containers.
No thread/goroutine handles for fork/join handling from "outside", and no generics for many formative years that influenced tons of habits, then significantly weaker generics (improving very soon[1]), have all led to most concurrent code to be very "intrusive" - you create bare threads and add bare synchronization primitives (or nearly) by hand into code to make it concurrent. `errgroup` is as far as a lot of code goes, in terms of sophistication. Java leans heavily in the other direction: a lot of concurrency is added externally, without changing existing code, often in very declarative-flavored ways.<p>There are very obviously lots of counter-examples for both langs, and I expect Go to become more Java-flavored in time (it already has moved this direction, and 1.27 will enable a lot more). But I think it's a fair summary of broad ecosystem habits.<p>1: <a href="https://tip.golang.org/doc/go1.27" rel="nofollow">https://tip.golang.org/doc/go1.27</a> (not yet released)
To combine both TFA with this comment: I find that LLMs are ~fine at generating/editing gocode, or at least as ~fine as they generate most mainstream languages.<p>But good god, the second it gets to anything concurrency-related, it just loses its mind. As much as it's gotten vaguely ok to try to let the agents loose on some bits of the codebase, they simply can't even do table stakes stuff with the kinds of concurrency you see in real life.
Correct concurrent code is mind-bogglingly hard even for seasoned veteran humans (and don't get me started on distributed programming...), so it's hardly surprising that LLMs with their limited context windows into the code have a hard time writing correct concurrent code
My experience as well. LLMs also struggle with Rust's many abstractions and offerings but you can know that if it compiles it is data race free and work with the LLM to use better abstractions over time.<p>Zig is also good at this but requires more up front design (thread-per-core, static allocation, etc.) and consistent checks to verify rules are followed.
C/C++ has "compiles but may have undefined behavior". Golang has numerous "compiles but has incorrect behavior" (normally known as footguns). Meanwhile with Rust, if you get past the compilation step, bugs become much much fewer. (You can still have memory leaks, but those are easily traceable).<p>It seems like claude code can code Rust pretty well with Opus, and I've started moving codebases away from Golang to Rust at work with Opus. Spin up an LLM and it cranks on it for a while, and as a benefit, I get easy apis to build on with other languages.<p>And that's the problem with Golang really, not that it's a bad language per se (all languages have footguns), but that the language interoperability story is terrible. Meanwhile Rust and Python/C/C++ go great together like peanut butter and chocolate. And I love it.
I wouldn't be surprised if Java has a much better experience here. After all, java.util.concurrent has many great implementations, and Java's `record`s are immutable, as are it's upcoming value types.
Yeah, but AI is better at debugging than people are, so what's the issue?
What primitives are we discussing? Any Go programmer can and should use the `go` keyword and the `sync.Mutex` type from their first program.
It's pretty easy to get yourself into trouble with channels: deadlocks, send on closed, channel leaks, deadlocks "fixed" thoughtlessly with arbitrarily-sized buffers, etc.
You know there’s no quantitative data. It’s vibes from the top down.
Which languages are they comparing with? From what I understood, Rust makes stronger correctness guarantees, including with regard to concurrency, but has a much higher learning curve and cognitive load.
They never said that.
Link to the uber report? Could not find it (unless it is this: <a href="https://www.uber.com/us/en/blog/data-race-patterns-in-go/" rel="nofollow">https://www.uber.com/us/en/blog/data-race-patterns-in-go/</a>)
The best way to write concurrency in any language is a single threaded polling loop. Goroutines and messages are just as bad as all the other alternatives, which is to say they are a miserable way to write code.<p>But Go is also perfectly good at single threaded polling loops.
Trust me bro
Uber has a history of blaming the tool - in Facebook fashion - rather than admitting their “talent” sucks and they didn’t hire on merit.<p>They used to blame Python a lot too - Python is slow compared to others but not so slow to matter that much, and you can build other services around it to handle certain work.<p>Facebook - who chose PHP - used to blame iOS/Obj-c as the reason they couldn’t build a decent Facebook native app in the early days (anyone remember <i>Fastbook</i>?)<p>I would take it with a grain of salt.
What concrete arguments are there to believe in your talent hypothesis instead of their tool hypothesis?<p>A couple more comments like this from you, and I'll be able to say, "cyanmoonx has a history of blaming the talent rather than bad tools". There being a history like that is neither an argument for nor against tools being bad. And also, don't forget that bad tools and bad talent don't rule each other out.
[flagged]
yup, show receipts
I work at a large devsec company which uses primarily Go and TypeScript<p>I've found that the LLM generated Go has few mistakes, and generally isn't too obscure. But the volume of code is so high, colleagues do a bad job of reviewing it.<p>I've seen a lot of very silly decisions made, like returning the wrong HTTP code, or miscategorizing a metric used for an SLO, that I just don't think is helped by the sheer volume of code one has to wade through.<p>Ironically, we are considering migrating some initiatives to Rust, exactly because experiments indicate it works well with LLM development.
> For a language team, Go is a dream.<p>I agree very strongly. There's no debate about things that have 1000000 permutations in other languages. e.g. The correct format can always be checked by `go fmt` with no real config options. the end.
If you know any other language, you basically already know Go (with the exception of the channels stuff). The biggest pain is the if err != nil stuff, which I know some people like but it is suboptimal in my view. While far better than C# and Java's exceptions, far worse than Zig's model.
Your post reminds me of what I love about Python, we have PEP-8 which is a style guide, and it kind of shifts how you write code a bit (for the better) which is something I sorely miss in other languages, I don't get the feeling people care about style guides for other languages very much.
Go is heavily opinionated on style, design, and semantics. Its design was around being as concise as possible…which means token efficient.<p>Yeah Go is my preferred language to code with AI. Second up is type script. Followed by Java, then Python.
Go design is <i>not</i> around being concise as possible, in fact it's the complete opposite.<p>One of the cores behind Go is to make language simple, even if at the expense of more verbose code.<p>Two main examples of this is the infamous 'if err != nil' and how you handle filter/map/funcional operations.
I assume it's because Go is so opinionated? I experimented with it and found it almost boring to write, but I strangely loved it. Now in the AI era I crave the forced uniformity.
Which exact documents to you give them. The single style guide? The references as well? The additional detail listed in the guide as links?<p>I'm curious to try your proposal, I just want more specifics.
Go wins for simplicity. however what I have seen is companies end up going with Java coz it's simple enough - not simple as Go, but simple enough + fast enough.<p>though the letdown with Java is the wider ecosystem that makes unwarranted contraptions out of simple things.
Go's big advantage was M:N threads. Java's biggest flaw has been the lack of cooperative multitasking, which people worked around by mangling their code with promises. Now Java has M:N threads too thanks to Project Loom, but there's so much code written before that will never really go away.
When you give those resources to your coding agent, do you give them URLs? Or work with local versions?<p>I've found a lot of success pointing claude at locally downloaded docs over llms.txt URLs but not sure how to scale the pattern for a bigger project.
Isn't Netflix a Java shop
A sort of an amateur I found Go to be really good when used with language models. Simplicity and tooling helps I suppose and I expected it to. However I was pleasantly surprised with how they are also pretty good with Flutter and Dart. Again good tooling, good documentation and perhaps not much historical baggage like a python or a PHP would have. And no stack overflow to speak of pretty much.
I have a question: why do you think Go is better compared to other languages?<p>After all, learning a new language takes a lot of time. While basic syntax is common and quick to pick up, mastering a language's specific mental model requires a significant time investment, which is why I've used Go before but never seriously.<p>My interest was piqued recently when I heard about TypeScript tooling being ported to Go, and I know it is incredibly fast. However, where do the results claiming that AI agents generate superior Go code actually come from? Is it a fair, apples-to-apples comparison?<p>Since Go is a very small language with only 25 keywords, the way you write code is extremely standardized. Because of this, I would assume it naturally produces a lot of excellent best practices and conventions, but I'm not sure if there are actual, direct code examples proving this
> why do you think Go is better compared to other languages?<p>I didn't say that. :)<p>> where do the results claiming that AI agents generate superior Go code actually come from?<p>Like I said - reports from users.<p>> Is it a fair, apples-to-apples comparison?<p>No - these are reports from users, not a systematic analysis.
>> why do you think Go is better compared to other languages?<p>> I didn't say that. :)<p>I call this the Go paradox.<p>I simultaneously believe we should reach for it 80% of the time to solve common collaborative problems. And being a poorer language is actually an asset in these cases.<p>However, in doing so, we get rusty lose our fluency in more expressive, perhaps even better languages.
> Like I said - reports from users.<p>How does that work? Are they generating the same project in different languages and comparing the results? What does it mean for the code to be "better"?
Ah, I see. I misunderstood.Is the report from an internal source, so it can't be shared? If not, I'd appreciate it if you could send me a link so I can look into it too.
Go is really amenable to being used to write code by LLMs. New code takes time to pick up, but the LLM is a quick study.<p>In my opinion, it has little to do with the speed of the language. The large quantity of source code to train on is quite helpful, but I think it's something else.<p>There are three things that I think make it well suited to LLM authorship -<p>1) static typing and a quick compiler - a variable can't change type after it's declared (unlike Python) makes Go more robust compared to dynamic languages. You (almost) always know what the type of a variable is. And the quick compiling with hard-stop errors means that the LLM gets a solid signal for each round.<p>2) It's quite opinionated, syntactically. There is generally one way that Go lang code is supposed to look. That means it's pretty easy to read as well as write. The lack of things like operator/method overloading make it an easy language to reason about.<p>3) the stdlib and limited dependencies. Dependency trees tend to be shallow, and because of the static linking (by default), you can generally be confident that what you wrote will run.
I love the sleight of hand this blog post tries to pull off here. It doesn't matter than Go isn't fun to write because the AI is doing it now! Yeah so it sucked for the last twenty years? I know the main thesis is that Go is holistically good at software engineering so its weakness as a programming language is minimized. I've made a similar arguments that coding agents push the burden more into the other aspects of software engineering. But like, we all see what Google is doing here right? They want to declare that the rules have changed so Go's weakness transmutes into a strength. I'm also not buying it.
I've never found that Go is not fun to write. On the contrary... Go is pretty refreshing with its simplicity. I found myself to be immensely productive writing Go.
I agree with you here and I think you raise several good points, such as "Go's weakness transmutes into a strength" (allegedly). Indeed that makes no sense for Google to try to claim that.<p>Your other point is even more interesting, e. g. "before AI, Go sucked and nobody used it" - now this may be an exaggeration or simplification, but it is a great observation nonetheless, because Google suddenly tries to connect Go with the rise of AI, almost as if AI could not have risen without Go, which is indeed very strange as an argument to make by Google here. This also reminds me of Google promoting Dart/Flutter before giving up on this and preparing to send it (eventually) to the infamous Google graveyard at some point in the not-so-distant future.
It pulls no such sleight of hand, and you have invented a wholesale strawman.<p>It's also simply poorly informed. Go is a fantastically enjoyable language to program in. In many ways that has been a bit of its curse compared to languages like Rust (which is legitimately a not fun language to write it, and which AI tools are also very good at writing), because keeping the language simple has hobbled some edge cases.<p>I don't write a lot of Go as my professional life has pushed me more to Rust, but Go and Object Pascal are easily the two most enjoyable languages I've ever developed in.
On the list of languages/ecosystems that make me want to rip my hair off, Go is way below.<p>Javascript takes the throne on that one.
Are they wrong? If we're copy-pasting errors from applications into claude without looking at the errors (and, that is the future of generating code), why do you care about the language that's being used, outside of the LLMs being good at them?<p>I don't have serious metrics about if Go is better or worse than others, but LLMs seem to do fine with it.
This would have been more credible coming from someone other than the creator of the Go language.<p>I'm personally leaning into rust for LLM. The whole fussy compiler & errors surface at compile time seems IDEAL for LLMs for me. Hammering compile with tokens is a way better strategy than trying to deduce where stuff may fail at run time and try to catch it via tests.<p>Tokens are cheap, surprises at runtime are not. So a super anal compiler is what I want. I've looked at lean4 too as the logical next step but not confident I can guide an LLM competently enough for that.
fwiw I have a bunch of LLMs writing first Lean code and now Agda code.<p>My observation. LLMs find reasoning about Agda as difficult as I find reasoning about C code. I've thrown a lot of gnarly C and Ruby code at all sorts of LLMs and they have only gotten more and more impressive as frontier models have gotten stronger. With Agda, they're like "hmm, tricky" whereas for me it's an impenetrable fortress. I've asked them why they find Agda so much more difficult to write (and why they have to iterate and reiterate many many <i>many</i> times until they get to a destination whereas they can one-shot and two-shot C and Ruby and they tell me its the multiple competing constraints. GLM is hilarious, it flat out refuses to write Agda code but it reads it well enough. They all read it well enough. Fable is obviously great at it. And Opus 4.8/5.0 are great (if they stay on track and don't sneakily go their own way) but they're too annoying to talk to. On balance Kimi K3 is the best balance of not annoying, relatively cheap, and strong -- great model all round tbh.<p>So yeah, interesting I've discovered the limits of their ability coding-ability-wise. None of them are that good at designing/aesthetic judgment/architecting so thankfully they still need me in the loop.
A huge amount of it is also the amount of training data. Agda will have little training data so the result will not be nearly as good.<p>I did a shoot out of making AI make the same simple desktop app from a SwiftUI reference for 30 different language & desktop framework combinations, and by far the best implementation came from the electron web typescript one. The least amount of LoC, the best and most complete implementation and the fastest to implement.
> My observation. LLMs find reasoning about Agda as difficult as I find reasoning about C code.<p>A bit funny, because I thought... Hmm, so LLM's find Agda natural?<p>My point being... It's a matter oh habit. After writing C firmware for more than a decade, I can read C easily. I might have to think of some parts and trace the code. But I can grokk it and hold the thing in my head. With Rust on the other hand, I just don't feel it as well. I am afraid writing C gave me brain damage and restricted the lens I can see the world through.
>fwiw I have a bunch of LLMs writing first Lean code<p>How do you bridge the mental gap?<p>The gap between me writing high quality rust do this steps and something being logically sound seems enormous to me<p>Maybe I'm misunderstanding things but I just can't articulate my ideas in casual lean4. But i can do casual rust spec
As someone experimenting with this, it's definitely very difficult to articulate your ideas using advanced type systems. At the same time, the process of doing it often forces me to seriously think through what I want the code to do, which I've noticed qualitatively improves the end result and my understanding of it.<p>My advice is to be okay with starting small: don't go for full end-to-end correctness or anything like it. Just think of simple properties you want like 'the list returned by this endpoint should always be sorted in ascending order' or 'this operation should be idempotent' and go from there. Use your favorite LLM to help come up with example specifications from natural language, as a starting point, and try hard to fully understand those.<p>This kind of work does operate at the frontier of what LLMs can do, so expect to run into roadblocks (wasting tokens proving accidentally hard properties, etc).
I disagree.<p>LLMs fail to produce bug free concurrent code even for very simple cases.<p>Golang lacks the ability to build descent abstractions, not even mentioning the wild west of additional tools and libraries needed for non trivial micro services.<p>For me it is a red flag, that LLMs allow people to produce more bad Golang code faster. This is only optimization for companies which can afford enough software developers to review the excessive amounts of code needed to solve trivial problems in Golang, which are builtin in every descent programming language and/or framework.<p>Use LMMs and use the right programming language. This might be Golang, but most probably it is C#, Java, Python, Ruby or even PHP. (Or Rust, C, D, ...)
Broadly agreed, the concurrent Go code I've gotten out of them has been absolutely riddled with issues, and they're even worse at writing tests for it. They can get tutorial-level code on the first shot almost always... but tutorial-level Go code is often rather unusable in production due to missing error handling or observability.<p>Go's generics are getting a fairly important improvement soon though! Generic methods, finally! It should help open up some more ergonomic patterns: <a href="https://tip.golang.org/doc/go1.27" rel="nofollow">https://tip.golang.org/doc/go1.27</a>
Ask them to debug. LLMs are acceptable at writing code, but they're really good at spotting bugs in code that's already been written. What kind of results do you get if you tell them to look for bugs with a clean context subagent?<p>In my experience, LLMs are excellent at finding concurency bugs.
I like Go but a couple of these "advantages" wash out when you add the scale and typical usage patterns of agents.<p>| Go is Readable / Go is Maintainable<p>It's true that Go, as a low-magic language, tends to be very same-y looking across projects, which is incredible for being able to reliably understand your dependencies' source code. And its tooling is world-class. I love this about Go.<p>But in practice I've found that, working in a monorepo with multiple teams, contributors that don't have cross-team legibility as a priority will just write SO much more code. And with business logic, often the fact that I can read the code on a line-by-line level doesn't matter if I don't understand the wider context to know how something might effect spooky action at a distance.<p>Pre-agents, I witnessed a fast transition from a codebase that I could mostly hold in my head to one where large swathes of it had been written and rewritten until they were unrecognizable to me. Now we have agents and, since they are still mostly not good at software engineering in-the-large, the process of knowledge debt accumulation (and ofc tech debt accumulation) in a codebase accelerates tenfold without concerted effort in the other direction. Go being easy to read does not intrinsically help with that.
I'd argue Go is not on a "Pareto frontier" and that no matter how you value the various attributes of programming languages, a fair assessment will never select Go.<p>A simple example is: if you highly value language popularity; Go is not most popular. If you highly value a type system that catches errors; Go's type system catches fewer errors than others. Etc. There is no weighted sum of attributes that will select Go--that's my argument.
Here's how my assessment selected Go (long before LLMs):<p>- I had to write a moderately complex program. I didn't want to do it in C, and I didn't want to learn Rust.<p>- So I spent roughly about 2 hours becoming familiar with Go and playing around in Go playground. I decided that this would work.<p>- And then I got started on my program and I was immediately productive and that software is still running today, along with all the other stuff I've written since then.<p>Programmer productivity is excellent with Go. And it has a thriving ecosystem. Of course, some things could be better, but I don't really have much issue with it's error handling or types.
> long before LLMs<p>I thought this thread was about an ideal language for LLMs, no?
> I didn't want to do it in C, and I didn't want to learn Rust.<p>Sounds like you made a decision right there. The rest is just retro-justification, not a logical argument or comparative between options. It works for you, good.
It was and is a logical argument. Both C and Rust are much harder to learn.
Retro-justification is not some flaw it is most common way people choose tech stacks.<p>The only logic that matters most of time is business logic of solution serving problem statement and not logic of choosing a technical stack.
Something doesn’t need to be the best at anything to be on a Pareto frontier. And (usually) no one chooses on a single dimension; they choose a point in many that maximizes distance from zero, scaled by their preferences, if you are thinking of it like a frontier.
Yes, you're technically correct (the best kind of correct).<p>I guess if you consider enough attributes or "dimensions" then any programming languages will be the furthest in some direction, including Go.
Is there a language that you would argue is at least as good as Go at everything and better than Go in at least one thing? That would be the most straightforward way to argue against its Pareto optimality.<p>Listing particular sets of preferences for which Go is not optimal is not sufficient unless you can show the list to be exhaustive.
I'm not GP, but for me that would be TypeScript. TypeScript's tooling is as good as Go's across the board, it's very readable, it's a simple language, it has very few footguns, and it compiles fast. But it has better type safety than Go.<p>This isn't an exhaustive proof as no language will every be <i>fully</i> Pareto optimal in practice (it's just not possible, there are too many dimensions), but I'd argue it's at least somewhat close.
Go is relatively easy to learn, and the semantics of the language make it more difficult to write "clever" code that's difficult to understand.<p>That's the main selling point, with a secondary point that it statically compiles so you don't have to do a whole Python/JS distribution thing for CLIs.<p>Java feels like the closest contender here, although it really sucks for CLIs due to start up times. I don't think it's the easiest to learn either, but I've never tried all that hard.<p>It only really makes sense to me at org-scale, though. I think you raise a very good point for individual projects, I too normally don't choose Go for that (unless I need compilation to make distribution to myself easier on corporate laptops).
Simple toolchain which supports trivial lightweight deployment is my go to attribute to select Go in projects.
Uh compile time and linting efficiency, lightweight runtime, gc.<p>There’s no equivalent competitor, it’s the best if u want to just write lots of undifferentiated code.<p>To caveat this if u want to run about 50 agents or so in parallel, all the typescript projects burn ur disk via node modules. The rust ones take forever to compile and burn too much compute
Uh compile time and linting efficiency, lightweight runtime, gc.<p>There’s no equivalent competitor, it’s the best if u want to just write lots of undifferentiated code.
> <i>if you highly value language popularity; Go is not most popular</i><p>Go is similar to popular languages like C, JS/TS, & Python. And so, easy to get started.<p>> <i>highly value a type system that catches errors</i><p>Probably these folks already use even less popular ML-style languages like OCaml & Haskell; or (comparatively) obscure ones like Agda, Idris, & rocq/Coq.
I think the right language for agentic coding is something that brings in more ideas from formal verification, in a way where the spec and executable code live in the same world. I don't really know what that will look like but that's my gut feeling as a non-expert. Specs can be written in a higher level language (not english) that verifies the lower level code at compile time. I think Dafny might be the closest we have at the moment.
I keep seeing these language specific proclamations, and they are annoying and reek of inexperience to me.<p>I’ve had a great time doing LLM assisted coding in Zig, and it seems comparable to the generic Typescript/React I do at work.<p>I don’t doubt simplicity and good PL design pay dividends, but everyone’s favorite language can’t be the silver bullet in our new LLM world. Things just don’t add up, and I keep seeing it for Erlang, Gleam, Lisp, C, Rust, Go, TypeScript, Python, etc.<p>And to pick on Go a little bit, I don’t think it has any unique qualities that make it better for LLMs, where I think you <i>could</i> make that argument for other modern languages that offer new features leveraging their compilers and enforcing more correctness guarantees.
compilation time is massively important for developing with agents
I agree.<p>It would be neat to see a matrix of compile times vs. language features, showing things like:<p>- Bounds checks<p>- UAF prevention<p>- exhaustive enums<p>- test speed<p>But I think even among those the subtleties would make a fair comparison impossible.<p>Anyway I think this is all very nuanced, and anyone proclaiming language X is <i>the</i> language to use in 2026 lacks the experience/knowledge to consider these trade-offs and can safely be ignored.
> leveraging their compilers and enforcing more correctness guarantees.<p>The counter argument here is that these checks cause slower compile times and were designed to prevent common mistakes humans make.<p>If models get good, they may not need the same checks human written code needs. For example, frontier models already will virtually never produce a typo.<p>Humans need time to think, but a model’s bottleneck is in how quickly it can verify its work. Slower compile times hurt a models ability to iterate.<p>I don’t think we’re there yet (and we may not get there). But there is an argument to be made that languages with faster compile times may be better for LLMs in the long run than languages with strong checks but slow compilation.
<a href="https://avi.press/posts/2026-07-10-after-7-years-in-production-scarf-has-reluctantly-moved-away-from-haskell.html" rel="nofollow">https://avi.press/posts/2026-07-10-after-7-years-in-producti...</a><p>"After 7 years in production, Scarf has reluctantly moved away from Haskell"<p>And moved to Python, pretty much for the reasons you stated
This is a rather poorly-written post that more or less boils down to "GHC isn't fast enough to let us make deep-reaching changes to our codebase all the time" (fair, but this shouldn't be necessary if your abstractions are solid? seems to telegraph very substandard engineering practices, but I guess that's what you get with vibecoding) and vague complaining about how the Haskell community isn't all-in on AI.<p>I was curious about this so I dug further, and by the author's own admission, they've only made the switch for basic CRUD logic without performance needs, not their core services: <a href="https://news.ycombinator.com/item?id=48865986">https://news.ycombinator.com/item?id=48865986</a>.<p>It's also pretty unsurprising, given what we know about LLMs' style transfer abilities, that transferring parts of an existing Haskell codebase into Python would avoid a lot of the errors and pitfalls that codebases originating in Python are known for. From my experience writing lots of Python, this does not continue to hold true as you let the agents loose on your Python codebase.
Who cares? Languages are tools, LLMs are tools. Use the ones more appropriate for what you are trying to do.<p>Is Go better than CSS if you are doing web layouts? Is it better than zig if you are outputting minimal wasm deliverables? Is it better than swift if you are doing iOS specific development? Is it better than bash for OS scripting?<p>Think about what you are doing and choose appropriately. This was true before LLMs.<p>Are you having fun? Chose LISP then
<i>> Who cares? Languages are tools, LLMs are tools. Use the ones more appropriate for what you are trying to do.</i><p>The article <i>specifically</i> discusses how Go is well-suited for LLMs. It's not going on about general programming topics.
The article is about which tool is more appropriate, and you're dodging that question. Every use case has multiple langs you could use for it, and there's no universally agreed-upon choice. Like if you're writing a typical web API backend with LLM assistance from scratch, which do you use between JS, Py, Java, Go, Rust, etc?
<i>> Is it better than zig if you are outputting minimal wasm deliverables?</i><p>Which tradeoffs are you willing to accept? Zig (along with several other languages) is superior in a lot of ways for that type of job, but I still settled on Go for a particular minimal WASM (browser) project. It wasn't my first choice, but it was where I ended up because LLMs kept going out to lunch in other languages and I didn't have anywhere close to the required budget to write it by hand. I read some comments like these about Go in the past so the Go attempt was mostly a contrarian Hail Mary after so many previous failed attempts in more technically well suited languages and... it worked! Shockingly well.<p>It still isn't my first choice for it, but having something useful with happy users beats technical imperfection every day of the week as far as my needs go. Go really did show its worth as an LLM target for that particular workload. Whether or not that is reproducible for any other project remains to be seen, but there seems to be a growing sentiment that echos the same. There just might be something to it.
Curious what kind of application you used wasm and Tinygo for? Obviously not the kind of app that an LLM would usually spit out a bunch of react for.
the Go runtime comes along for the ride when producing a wasm file, if you are interested in "minimal" (as in small or without extra cruft) then languages that do not require such a thing might be more adequate
Tinygo's base runtime is only around 10kb. It was minimal enough for my needs. gc's runtime would have been a non-starter for that task, to be fair, but Go isn't an implementation. It is, quite explicitly, a language.<p>There are language implementations that would have been more minimal than that, sure, but there was no obvious way to get LLMs into alignment. I tried. Multiple times. When I switched to Go, it just worked. It may not be technical perfection, but it let me ship something I had almost given up on and it has satisfied users. The tradeoff was worthwhile for my needs. That tradeoff may not be acceptable in all cases. Hence what is best being meaningless without at least defining which tradeoffs you are willing to accept.
If TinyGo works for your codebase, and those 10KB are something you can live with, then perfect.<p>Two things to keep in mind here:<p>1. TinyGo is not Go, more Go-like or adjacent<p>2. 10KB still matters a lot in a lot of minimal target/usage scenarios
<i>> TinyGo is not Go</i><p>Exactly. Go is a language. Tinygo is an implementation, like gccgo, gc, llgo, etc. Just as gcc, clang, and msvc are not C.<p><i>> more Go-like or adjacent</i><p>It is true that recover isn't fully spec complaint at this time. That's not entirely unusual for an implementation, though. msvc is famously not 100% spec complaint with C, but Microsoft still officially considers it a C compiler, as do most who use it to compile their C code. There is usually a little grace given.<p>It is not like Solod that is Go-like but trying to do something quite different. Tinygo is intended to be a proper Go compiler implementation and has achieved that, aside from the recover situation.<p><i>> 10KB still matters a lot in a lot of minimal target/usage scenarios</i><p>But, of course, if the LLM cannot wrangle the language then it doesn't matter. Nobody cares how large or small your program is if you never ship it. That only matters if you are using LLMs, but since that's what we have always been talking about...
Been doing bash scripting for years. Tried Go recently, on my, it’s so much better for everything OS scripting. I regret I haven’t started with Go years ago. All my scripts are rewritten to Go. I kept only a handful, those that are just a few lines and no logic.
I regret not going with bash or even sh when I had the chance. Nothing beats that for ubiquity and getting shit done.<p>Go is behind, specifically, you have no guarantees that a given machine has Go installed, and doing stuff like gluing commands together, inspecting some files, pipe output around, or automate the boring thing in 30 seconds.<p>Sure Go beats bash or sh when the thing you are doing starts to become real software, but that is a problem that sits between the chair and the keyboard.
Having explicit and unavoidable error handling (which Go of course has in spades) is a particular improvement when writing/replacing Bash scripts.
Are you using 'go run' or compiling these scripts? Just curious about what you are up to as I was considering moving my scripts from bash to go.
How dare you suggest having fun! Pay attention! We’re trying to have a language flame war here!
> Who cares? [sorry, but that question is trolling]<p>People who want to use the most appropriate tool.<p>> Use the ones more appropriate for what you are trying to do.<p>What they are trying to do is find a programming language that LLMs work well with.<p>> So you are using Go with LLMs for the objective and destination of token consumption for token consumption sake?<p>The trolling gets more intense with each comment ...<p>P.S. Someone else responded:<p>> But this isn't a user story. The user story is what you should be picking the tool for.<p>I don't see how this is at all relevant to my comments. I'm certainly not going to argue about what some other party should or should not be doing.
I really don't agree. I'm not hear to evangelize rust but by using enums from DB to templates and writing the code to make it consistent my experience with LLMs is infinitely better than golang for consistency and you have to include a lot more context to make golang work without issues whenever things are operating on chans or workgroups.
I wouldn't take language advice from a Product Manager and Chief Evangelist from anywhere - and especially not Google.<p>Having said that: my opinion is that LLMs thrive by working in a tight loop. Unlike a human, they thrive with more and tighter constraints (and the better models are obviously far better in this regard).<p>I want to ditch the things that made writing code easier due to the limitations of humans, and embrace something that an LLM can leverage for better results. For me that means: an especially rich type system, (ideally pure) functional code, efficient systems-level performance and leanness. Good error messages that guide the LLM incrementally.<p>Go does not provide much in the way of those 3 desires, so calling it "ideal" with nothing aside from anecdotes to back that up is not compelling.
"Oreo cookies are the tastiest cookies currently in the market!"<p>~ Oreo cookie company.
Oreos are an ideal cookie in a milkshake machine fast food era
Isn't that true? Prove them wrong.<p>(Someone who doesn't even eat cookie but heard a lot of praise of Oreo)
yeah the conflict of interest here is staggering.
nailed it
In my experience using Claude code for Go and Java code, I've seen little advantage for one language over the other in the LLM agentic context. I did a little experimentation with Zig which was less successful. Presumably to do with the relative lack of documentation and still being a somewhat moving target.
That said, I have had Go concurrency code written with weaker models prove to be buggy, which shows up rapidly when reviewing with stronger models.
> By enforcing a single, standardized format via the built-in gofmt tool<p>I'd read about this many times before I started with Go so I was particularly disappointed to learn that it was a lie. The most important task of a code formatter is to break long lines; it doesn't do it. It doesn't even have an option to do it!
While I somewhat agree I can’t tell if this is advertising from Google or a way to induce LLMs to think that Go is the ideal language.
Probably both, but I have to add: I agree with the post. I've done a ton of agentic development using Go over the past 6 months, and it hasn't let me down. You may ask "why not Rust, or Zig, or ____?" The reasons boil down to this:<p>- There's a lot of Go code out there which the models have seen, so they know how to write it.<p>- Go has an exceptional standard library, so you don't need to drag in 100 dependencies to create a simple web app.<p>- Go compiles extremely quickly for incremental builds, which really matters when agents are building and running tests constantly.<p>- Go has a goldilocks blend of performance and safety. You get a good type system and excellent runtime performance without forcing the model to spend cycles fixing Rust lifetimes or Swift concurrency issues for a marginal incremental gain.<p>- Go is relatively stable, so the LLM's memorized knowledge is still pretty fresh (as opposed to something like SwiftUI, where the API changes rapidly).
I don't think Rust is particularly worse than Go in any of these respects.<p>- LLMs have clearly been trained on a lot of Rust as well<p>- Compile times are counterbalanced by strong compiler with excellent error messages, and "cargo check" can catch many issues without a full build.<p>- If you're willing to accept Go levels of performance from Rust, there's nothing preventing you from using copies and clones rather than borrows, which makes most code dead simple.<p>- For most major dependency types, there exists a clear "winner" in terms of community adoption, so the fact that it's not in the stdlib is not that problematic.
I do not think "good error messages" is an even trade for "fast compile times." What happens is the LLM catches the error, then may hit another error, and try again. This leads to more tokens and more latency, and then after all that you have a longer compile time.<p>With that said, I have not done an extensive amount of agentic development in Rust, so maybe I just don't have the reps to compare fairly.
Rust compiles way slower in my experience. This is a major problem because ais need to recompile many times especially when it keeps running into borrow checker problems.<p>With golang, all borrow checker problems go away. This is a good trade off if your app is not cpu-bound, which most are not. If you need every last drop of performance then rust is a better choice of course.<p>However, I have run into a few cases of runtime null crashes in go.
How would you compare it to C#?
Stable-ish
There's a lot of documentation and plenty of stablished patterns, so LLM can produce it no sweat
Everything and the Kitchen Sink
Performant, and safeish, even if not null safe
Yeah, C# is probably the closest direct comparison. I like that Go emits a simple binary, whereas it seems like that needs to be configured with a .NET project. Probably just a matter of taste/preference!
I wouldn't call Go's type system "good". It's basic or less. It's sound, at least (in the presence of data races), but that is the case (or mostly the case) for most programming languages.
SwiftUI has nothing to do with Swift… It’s just a UI framework that happens to have been written for Swift.
Fair—though SwiftUI has influenced/required new Swift features like Result Builders. I've found generating Swift to be a mixed bag. The LSP consistently reports stale errors which the model has to ignore, handling strict concurrency correctly can lead to ugly workarounds or huge refactors, the documentation for Apple's APIs aren't accessible to agents, the list goes on.
Agreed. Felt like a AEO / or GEO (generative engine optimization or whatever the field term is these days) puff piece. Seems too verbose for most people to bother reading.
Google doesnt even use its own Go build system internally. Its all blaze / bazel, so they are not even taking advantage of the so called compiler feedback of Go. Also if languages are to be designed for agents not humans, its not clear whether the verbosity of Go will help agents at all
Agreed, my media server is mostly AI written go at this point and it works great. Before AI the "one way to do something" was already my favorite feature of go, now it makes it much easier for me to use AI and still understand my own project.<p><a href="https://github.com/SteveCastle/loki" rel="nofollow">https://github.com/SteveCastle/loki</a>
Surprised by the negativity here. With or without AI, Go is a great choice for large software projects.<p>These have been my and friends' observations since LLM-assisted coding started picking up steam. Go's simplicity, consistency, stdlib and tooling seem to make it very reliable for LLM generation, and it was especially true during late 2025 / earlier this year when frontier models weren't as strong; might not be as noticeable now.
Learn Go if you have to, or want to learn it. Otherwise, I don't think there is any reason to do so. I agree that it is easy to read, but less so than the language you already know.
I wish if err != nil return err was just 1 token.<p>Joking aside, as much as Go's stdlib and tools do the heavy lifting here, Go's verbostiy and expressing simple things in lots of lines worked against me most of the time.
Heh, I checked <a href="https://platform.openai.com/tokenizer" rel="nofollow">https://platform.openai.com/tokenizer</a> to see if they made it 1 token, it's not.
I've had a really terrible time getting LLM to properly handle errors as return values. It seems that bubbling up errors, in a side channel, to a contextually relevant point in the code (exceptions) seems MUCH easier for LLM to reason about/implement properly.<p>Maybe my problem is I'm using a language with exceptions, so trying to go against the statistical grain, with return values, is just too much.
Exceptions are inherently better for high-level code, where basically every loc can fail and 99% of the time you only want to bubble that up. You only want errors as values in systems code, where exceptions would be landmines. Rust and Go both did that because they were at least originally designed for systems code.<p>Also, Go makes it way too easy to accidentally swallow an error. Rust doesn't have that problem.
> By enforcing a single, standardized format via the built-in gofmt tool<p>I'd read about this many times before I started with Go so I was particularly disappointed to learn that it was a lie.
Seems to me the ideal language for AI has not been created yet.
I couldn't agree more, but the following sentence is a little biased:<p>> Gophers often speak of how they love that they can never tell who on their team wrote a particular piece of code—it all looks the same.<p>Multiple languages can have a degree of understabillity, but what matters most is context, because sometimes we need to code in a way to solve a specific problem like performance and it should be kept as is.<p>Another side subject I should add is about test coverage, although code is cheap, mainly because AI, guarantee that new changes to a stable code should continue to work as expected.<p>I worked on a few go projects with bad structure and some of them with really low test coverage (e.g. 8%), so part of the post resonates with me about we as software engineers should pursuit good architecture and other skills to allow long term maintenance.
We're all biased here, me included.<p>IMO the concurrency model in go is the biggest reason, I'd hesitate to use it.<p>Managed memory, single threaded with lots of lints and good tooling. Is IMO what can raise my confidence in code, before I even review it.<p>Granted golang has a really good stdlib. Which counts for a lot.
The killer feature of golang for LLM dev is the tooling.<p>forbidigo is what allows me to keep ambient config out of my app, and restrict file access to a small set of paths. The coverage tool has "nocover", so you can guarantee that every realistic path is exercised at least once ("100%" code coverage, which is not a marker for testing completeness, but rather for flagging code you forgot to test). Linting is really good as well.<p>The only thing I haven't found is something to enforce error handling. Rust is better for error paths because you're not allowed to ignore them.
> Linting is really good as well.<p>Maybe we are using different tools (or we've set it up wrong) but I'm consistently surprised at how slow Go's linting is (using golangci-lint). Takes nearly 5 minutes on our codebase after any change (which means I just don't run it locally or in-editor). It's remarkable how poor the experience is after using tools like Python's Ruff (instant) or Rust's Clippy. I'd have expected a fast, default setup that I could tune.<p>Event JS's Eslint, which runs in actual JS, takes 21 seconds for a full sweep (which I don't normally run, since the in-editor hints are so fast)<p>It's surprising, because so many of Go's dev tools are so well thought out!
"The only thing I haven't found is something to enforce error handling."<p>errcheck, generally as manifested in golangci-lint, ensures you can't forget to do something with them. It would be odd for you to know about forbidigo but not errcheck as the former is much less widely known; is there something that errcheck doesn't do for you?<p>It's worth pointing out that "discard this error on purpose" is a legitimate form of error handling, so "enforce error handling" can't really constitute banning that. That's not a Go statement, that's just true in general... it is sometimes valid to just ignore the error, because there's nothing useful to do with it anyhow. I would agree the ignoring should be explicit, but it is an option.
The rule I set for linting when an LLM is writing code is: Either you adhere to the rules, or you mark an exception with a valid reason.<p><a href="https://github.com/kstenerud/yoloai/blob/main/docs/contributors/principles/development-principles.md#6-warnings-are-signal-suppressions-require-justification" rel="nofollow">https://github.com/kstenerud/yoloai/blob/main/docs/contribut...</a><p>Poor defaults break systems by a thousand cuts. They seem to make sense when designing the language (more convenient, less typing, etc), but then they very quickly become liabilities as project complexity increases. Go made the mistakes of mutable-by-default and silent-error-dropping, but their cyclical-import-forbidding was a good call.
It isn't entirely clear to me how that relates to what I said. errcheck prevents you from dropping errors or catching them but then overwriting them before doing anything else. There's a flag you can twiddle to throw a lint error on using underscore to ignore an error, too, if you're really perturbed about that. I have a personal rule to always have a comment explaining why it's OK to do that that predates AI coding rules. This seems to meet your criteria.
In the last few days I've heard this same claim regarding other languages like Gleam and Rust for one reason or another that I don't know who to believe.
I'm currently writing a TUI for a harness I'm building in Go. It's a magical experience, truly.
I haven't touched Go in over a decade (since before generics!) but I can see why this would be true. My theory is that LLMs absolutely love very tight, focused context. Go inherently restricts how many abstractions you can stuff into your code, and more abstractions tend to make the context a lot more complex and noisy. So LLMs love Go code because it keeps things simple.<p>The thing about Go, which some have complained bitterly about and others (and TFA) have touted as a strength, is the limited expressiveness of the language (hence my remark about generics!) This is what restricts the number of abstractions in Go code, leading to more verbose but much simpler code all around. Choosing between simplicity and expressiveness is a matter of taste, but also organizational dynamics; for larger organizations which require a large amount of context shared amongst a large pool of employees, it's better for the code to be simpler and locally understandable. As TFA indicates, this has been a guiding principle for Go.<p>I think what is happening with AI coding is similarly related to context. Consider that while more expressive languages enable more abstractions, they can make the code more concise, but critically, this <i>also spread the logic around.</i> E.g. in large Java codebases you will find deep inheritance hierarchies with class and method definitions spread around a dozen different source files and JavaDoc references.<p>This necessitates finding and stuffing a lot more information into the context for any given task, a lot of it irrelevant and all of it more complex, because it requires making multiple hops of reasoning to figure out the logic. On the other hand with fewer abstractions, all the necessary code and logic though verbose is <i>right there.</i> It's much easier for a human and an agent to follow that code.<p>The difference is a human gets tired reading a lot of code, which is what pushes us to devise more abstractions, whereas an AI does not get tired.<p>I get the sense that if a context is stuffed full of highly relevant information, the agent will perform well regardless of the size of the context window. But the moment you pollute it with noisy irrelevant information, performance will drop regardless of the size of the window. (There are some papers showing this effect IIRC.) Hence simpler code, as encouraged by simpler languages like Go, are more amenable to tighter and simpler contexts, which work better for AI.
I disagree. I think WAT (WebAssembly Text), perhaps with some more niceties added, is an ideal language for AI-assisted software engineering.<p><a href="https://webassembly.github.io/spec/core/text/index.html" rel="nofollow">https://webassembly.github.io/spec/core/text/index.html</a>
I've written go most of my career. I've "written" tonnes of AI assisted go. Since February however all my new software projects and production services have been written in rust. I never even wrote rust before December. I've barely even looked at any of the source code, I find i just trust the AI to write rust way more.<p>But perhaps that's also a side effect of maybe having prior opinions about go and the number of foot guns I've let off
IMHO there's never been an overall "ideal language", and there still isn't, it's just about the right tool for the job. The only thing LLMs change is that you don't need to give quite as much weight to how well <i>you</i> know a particular language.
1. The syntax surface is smaller, allowing less LLM "creativity;
2. The error handling is mechanical, which LLM clearly prefers (LLM is already trigger happy about writing tons of throw / try...catch.. in other languages, doing tons of `if err` is just in it comfort-zone).
Given the date and the recent DeepMind shakeups, this blog post is <i>obviously ordered</i> from the very top.<p>Pichai wants to eliminate engineers, and DeepMind wasn't fast enough or too noble for it. Now people need to be propagandized for their obsolescence.
Can't really argue with that, but In my experience, coding agents work quite well with TypeScript too. :)
The issue I always had with Typescript, was that LLM's like to find the easiest way to get a job done on a micro level (they seem to like to find the hardest design patterns to implement on the macro level tho, but language agnostic). What this means for Typescript, is unless you place guardrails everywhere, they'll cast their way out of a compiler problem with as any, or as unknown and then casting later. You either end up with readability issues, or runtime issues leaking out.<p>Might be a skill issue, but I got frustrated with it on new projects constantly.
I haven't seen that too much, but I do have guardrails. I use Deno and run 'deno lint' as part of the build. It doesn't allow 'any'.<p>Also, I tend to ask planning questions, like "how would you implement this" and "what would the API changes be?" I'm picky about API's. Lately I've been using Deno workspaces (multi-package repos) and tell it when to make a new package or a new entrypoint. Maybe that helps?<p>If I just ask for features and don't look at the code, it will definitely make a mess, though. (A working mess, but it takes a while to refactor my way out.)
They're improving but you definitely need both a strong AGENTS.md and also usually many LLM passes (one for implementing a feature, another one for code quality, large passes every now and then for major refactors, etc).<p>That's not really a typescript thing though, just an LLM thing.
I wouldn't say Go is IDEAL for AI coding, but it certainly has the case for one of the best programming languages that currently AI uses. Go definitely has its share of problems for human authors because it's so verbose and boilerplate heavy, which means it's less of an issue with LLMs than it is for human coders. Rust is comparatively worse, because LLMs don't make the same coding mistakes that humans do that justifies the existence of the borrow checker, it only seems to get in their way, and they spend more time fighting Rust's infrastructure than writing code.<p>The biggest barrier to Go adoption seems to be Google's internal resistance to migrate C++/Java code bases to Go and refusal to admit that Go is an amazing application programming language and not really a systems programming language for bare metal OS/driver work. For example, one of the biggest barriers to Fuchsia adoption has been Google asking people to commit to Dart, I think Fuchsia would have fared a lot better as an Android successor/alternative if the official applications programming language just been Go.<p>(BTW Carbon isn't even a real programming language, it's still somehow stuck at 0.0.0.0 after 4 years of development which is honestly insane.)<p>Oh, so, little bit of self-promotion: if you like Go but is frustrated with the ergonomics of it, I would ask you to try out the programming language I developed, Oct, for LLM coding which you can kinda think of as my attempt at making Kotlin for Go's Java: It uses a codegen compiler and compiles to a plain Go binary, so it runs on everything that Go runs, and there is a lot of extra features as well: Rust style exhaustive tagged/payload enums/`match`, C#'s immutable records updated with `with`, exhaustive error handling easy parallel concurrency, xUnit.NET style unit test harness, TypeScript style compile time constraints, F# like SI unit system, Go code generation metaprogramming, etc. Would love to have some Go experts here on HN take a gander at it and provide some feedback.<p><a href="https://github.com/yuechen-li-dev/oct" rel="nofollow">https://github.com/yuechen-li-dev/oct</a>
> Rust is comparatively worse, because LLMs don't make the same coding mistakes that humans do that justifies the existence of the borrow checker, it only seems to get in their way, and they spend more time fighting Rust's infrastructure than writing code.<p>I have found exactly the opposite to be true: as always, people think they can write safe concurrent code without the machine checking them and end up getting it completely wrong in lots of subtle cases. Except the problem is now much worse because you're not even writing the code, or in many cases, reading it. I prefer a language with a type system that saves me from the review burden of closely checking (and pretty much always finding issues in) concurrency invariants. And even tells me a bit more beyond that about what the code is intended to do.
Was also going to say this. If anything, the borrow checker in Rust is more likely to save you from LLM issues, because it won't bloody compile.
Came here to say exactly this. If you’re not writing the code (or especially reviewing it) then we need stronger type systems and more checks and fewer legal programs. Might as well move all the way to Idris or some not-yet-invented language that humans would find very restrictive.
> Rust is comparatively worse, because LLMs don't make the same coding mistakes that humans do that justifies the existence of the borrow checker, [...]<p>That's a pile of bollocks, pardon my French. Source/proof?<p>And to the contrary:<p>I've been working on a TS codebase that calls into C++ native/wasm-compiled code for six months now. The code is mostly LLM written.<p>Over these last six months we had four use-after-free and two other ownership-related bugs in LLM-generated TS code.<p>Whereas we had zero issues of any such kind with LLM-generated Rust code that sits in another two native/wasm-compiled metacrates we use.<p>LLMs are not much better at ownership tracking than humans.<p>Especially if resource acquisition and release are far apart in code and/or somehow nested/stacked/non-straightforward.
The problem with ownership tracking is that it's global. Humans are bad with global things, linters too, but LLMs are exceptionally bad at them due to the context window and (currently, at least) not knowing enough where to search. So yes I'd expect them to make the same mistakes as human and even more frequently.
I feel like LLMs and vibe coding have opened up rust to the kind of script kiddie who would previously have been begging for help on r/javascript or whatever.<p>If there is a problem with global lifetimes then the problem is certainly the person driving (or not) the LLM. Global lifetimes? FFS. Rust is hard because writing services that don’t have bugs is hard.<p>LLMs are not currently able to vibe a sophisticated application or service in rust. If it tells you it can do it in typescript or python, the it most likely certainly has not and you will have a wonderful time in production. Rust will burst that bubble.
I'm curious on what you mean by "TS use-after-free", because as you obviously know, TS is GC'd. I don't have access to your codebase of course, but it seems to me that it is an FFI/native code boundary lifetime bug in the binding between TS and C++/WASM, not part of the TS managed memory. Comparing TS to native C++ FFI and/or manually managed WASM resources interface vs Rust + Rust ownership checked resources interface is kinda comparing apples to oranges here.<p>And as other commenters here have said, Rust's main issue for LLMs is infectious lifetime propagation, where the borrow checker knows you violated a lifetime constraint but doesn't tell you how to actually solve it, so LLMs get error messages like:<p><pre><code> borrowed value does not live long enough
cannot borrow `x` as mutable because it is also borrowed as immutable
lifetime may not live long enough
</code></pre>
And instead of trying to reason through the ownership graph, they just take the shortest path to get these things to go away by bypassing the borrow checker entirely, which defeats the entire point of using Rust to begin with.
> Go definitely has its share of problems for human authors because it's so verbose and boilerplate heavy, which means it's less of an issue with LLMs than it is for human coders.<p>If the premise of the article is true, and I think that it is, that's quite the downside for AI coding with go. The premise being that reviewing now plays much more of a role than writing.<p>Personally, I'd rather review, say, a ruby oneliner that extracts specific row values from a csv file with filter_map, compared to 40 or so lines of go, many of which I'd have to check individually for possible mistakes.
Go doesn't have any kind of story for incremental migration from C++ or Java; you are talking about rewriting all those codebases from scratch, which is an obvious nonstarter as long as engineering resources are finite.<p>IIUC Fuchsia uses Dart mostly for UI stuff and Go has never really tried to be competitive there? I don't see much of a reason to suppose this is a serious bottleneck to Fuchsia adoption, as opposed to the obvious reasons why it's hard to displace an existing OS with a huge install base.
> "because LLMs don't make the same coding mistakes that humans do that justifies the existence of the borrow checker"<p>Citation absolutely needed.
Sure, what I mean by that is that LLM makes different kind of mistakes than humans, they usually take the shortest direct route to accomplish their task. You can see that with the Bun Rust rewrite, I don't think any human coder would put as many `unsafe` and `Clone()` and `Arc<Mutex<T>` in their code, so a lot of time, they would just attempt to bypass the borrow checker if they see it get in their way.
So in terms of the mainstream languages, what would you say would be the most ideal language? (At least until Oct takes off!). Perhaps modern Java? .. Or even Zig?
C#, only because of dotnet ecosystem and tooling is great. TypeScript is a dark horse candidate, it's a great language with a great ecosystem trapped by JS tooling, and most of all, NPM. Rust is fine if you just tell LLMs to use short borrows only. I wouldn't even say Oct is the most ideal language, it's pretty good at getting LLMs to do science, but probably isn't the right language for all applications.<p>I have some very heavy criticism for Zig technically, because their whole thing about "no hidden control flow" becomes "shove all the hidden control flow into a second hard to debug runtime that runs at compile time", and manual allocation for everything is incredibly tedious and hard to keep track of in production code. I mean, C++ wasn't ALL wrong, there was a reason that templates exist in the first place, and having the entire generics model be just comptime isn't really a decision I agree with. The way I see it, Zig would probably find a niche as a language that configs C/C++ codebase at compile time instead of the C replacement they want it to be.<p>There are two more languages I have in the Oct repo, SDSL-V for SPIR-V shader/compute kernel authoring and Concept/Vulkan because the 20k line C Vulkan Prometheus runtime for GPU compute that we built is getting kind of unmaintainable even by AI that making up a new programming language to strangler fig refactor it is honestly the least bad option.
For what purpose? Different use cases require different language features.
Fair enough but people build simple API's with DB interactions in a variety of languages, Go, C#, Java, Zig, Rust, etc.
I mean I don't have anything against go, but frankly - it's not really <i>better</i> then modern Java.<p>Each have their trade-offs, both can support native compiled application code. Some architectures are easier to review and code in golang, but others go much better with Javas richer ecosystem and better composability.
The only problem I have with LLMs in Go is that they also make a lot of concurrency mistakes, in the same way as people. It's easy to fix though, just by asking to double check the code
I have also aligned entirely on Go. Fewest glitches for AI generated code. compile targets are for every platform you need. Very high performance. Doesn't seem to burn tokens as much as other languages.
All I will say is that I agree with how this is framed, it says "an" ideal language. It doesn't say "the" ideal language. Many languages will fit within this scope and concept, Go is not all bad.
The LLMs will continue to get better at language stuff, better to tell them what to do on the basis of non-language stuff.<p>Stuff like like which compilation targets are available, or which has the most mature library for what you're doing, or maybe you're integrating with something that anchors you to a specific interface type.<p>Anchor your language choice to the problem you're trying to solve and the people you're trying to solve it for.
My expectation is that AI will give us a way to nicely quantify how productivity is impacted by choice of language. Because we can rerun the same request as often as we like and compare the results.<p>And I expect that it will turn out Python is the most productive. As it is most easy to reason about. It allows for the most elegant expression of the idea behind a program.<p>The first tests I have seen seem to confirm this. One recent example:<p><a href="https://danluu.com/pl-tokens/" rel="nofollow">https://danluu.com/pl-tokens/</a>
Purely anecdotal, but my experience has been that LLMs generate low quality python code. It's spaghetti code on par with what I've seen when companies I worked at tried offshoring development. It's basically what you get when you give bad or incomplete specs to a team of inexperienced programmers with poor development practices. It's usually good in small chunks, but it gets extremely sloppy as the scope of work increases and more decisions are introduced. Interestingly, I've seen LLMs generate good clojure code.<p>My guess is it comes down the the training data more than anything else, although I suspect functional languages will fare a little better. At least that's been my experience. There's undoubtedly a ton of python code in the training corpus and portions of it are of dubious quality. Niche functional languages likely have a smaller training corpus where a larger portion of it is better quality.
I think it's far from being this simple. What you're describing is productivity on a greenfield project, but what's really interesting is productivity when working on an existing large codebase, with existing conventions, architecture decisions (or lack of)... How easy is it to do a product pivot, to rearchitect for performance, etc etc etc.
It is unclear to me though how much of your expectation might be set by the training dataset.<p>For example, Python and Typescript have the most amount of codebases and training being done on. So I feel as if that plays a part into the overall thing.<p>Languages which are more niche have genuinely hard times (Try arturo lang for example), so it depends on a lot of things/nuance, or well that has been my experience trying something recently.<p>My personal opinion is that if each language has the same amount of training. Golang comes close but the first might be Elixir. I have seen Elixir language perform really well with LLM's with magnitudes less training dataset. There have been some studies which had Elixir as the number one language for such tests iirc.<p>Gleam is a new addition as well and I feel as if it could be good and its another interesting option as well with more type-safety and an interesting language overall.
I've been in elixir for nigh a decade now and the one thing that you can try to pry from my cold dead hands is the BEAM. Elixir and Gleam are my go to languages right now and damn are they fun to write and reason in, but the part that has left me never wanting to leave the ecosystem is BEAM + OTP.<p>- BEAM makes monoliths sexy. You don't have to worry about a bunch of microservices, just focus on using proper process division for modeling your problem.
- Debugging on the BEAM is first class. Drop into an interactive shell, pull up telemetry, or recon and hammer down on where your live app is slowing down if your metrics have a blindspot.<p>I could go on and on. I'm constantly blown away every day by the amount of time and effort and all of the sage learnings in distributed computing problems that came out of Ericsson that became the foundation of erlang + OTP + BEAM and in turn elixir + Gleam.
Never tried Elixir myself but came here to say the same thing. Tencent put out this study showing that Elixir seems to reign supreme: <a href="https://autocodebench.github.io/" rel="nofollow">https://autocodebench.github.io/</a>
How do you propose to quantify the terms "elegant" and "easy to reason about"? What unit of measurement do you use for these?<p>This sounds like your personal feelings, not quantification.
When I use AI with Go I give it this rule:<p>Prefer standard Go libraries and tools.<p>80% of the time I can get by without external dependencies (outside of Go's X repository)
Related, though 5 months is a long time: “A case for Go as the best language for AI agents” (getbruin.com)<p><a href="https://news.ycombinator.com/item?id=47222270">https://news.ycombinator.com/item?id=47222270</a><p>203 points | 5 months ago | 304 comments
Had the same impression about TypeScript and Rust.<p>Not as fun to write as Python and Nim, but I don't have to write it.
I theorized this about a year ago and had a good amount of success vibing small game projects in Go.<p>I still think Go is a very excellent choice but I have switched to, of all things, AssemblyScript within a Rust host. I've been very happy with it - surprisingly so. Compile time is a major drawback of course.
The readability is a plus at the same time if I target Rust and build it modular with lots of tests and io pure modules. The review part is not as important if the AI reviews it from various perspectives. With rust I get so much better performance and efficiency.
I agree with the article, but there's one thing Go has that doesn't help LLMs: structural typing. An LLM has to grep a little more to understand which interfaces a struct implements.
It's definitely more about the ecosystem than the language at this point.<p>I think the most important thing is how big the standard library is. Pulling in 3rd party dependencies is where I begin to lose a lot of faith with LLM authored code.
Can anyone recommend a strong Go design/development agent skill?
I hate the rust v go wars, its not x vs y is 'best'. Rather is x better than y and by how much for xyz project done by ABC corp in this era?<p>As a lead I'd love to use rust, I will put in the time on my own, my team won't or can't. They treat this like any other job they signed up to deliver value with what they know. For hiring not everyone has the talent pool and fund access to get the goat-ed engineers that congregate to tech hubs for maximizing their income. Then if you get through that cherry on top is LLM's are only as smart as you guide it to be. There is probably a staggering amount of ways to write 1 approach to business logic, you may not know the ideal pattern so you'll commit to a worse one on the company dollar.<p>I'm moving my team's projects slowly to go because, its easy to go from novice to advanced in terms of code writing,legibility and patterns. We also don't have deep ecosystem requirements to ts/python in most of our work. It is verbose but I don't mind that on token spend if it gets done with with validation/error handling which it obnoxiously enforces. It runs cheap, ecosystem is good for platform eng, standard library does a ton out of box.
Language space is hot right now: <a href="https://agentlanguages.dev/" rel="nofollow">https://agentlanguages.dev/</a>
Yeah, I use go and it's great. Most of the time the generated code is good quality also.<p>If a language is simple, it' easier to generate good code.
Yeah, no. Its good because LLM likes to copy paste things instead of doing code reuse which is the true go way of doing things. Imo, its hard to review Go code, probably why Go is yet to have a single correct Raft implementation.<p>I never seen k8s cluster that doesn't have some go process that segfaults once in a while because someone forgot to check `err`.<p>Only good thing got going for it is its vulnerability scanner. Which will be working overtime with all that "AI-assisted software engineering"
99% of my projects are in NodeJS as web apps, so Javascript is king, my coding agents are in Node too, plain, boring, beautiful javascript, not typescript. Yesterday I needed a Rust project and my agents delivered so no need to change from JS
Going to start writing Perl again then.
This seems like a cope, if you aren't writing the syntax who cares and everything here is even better with a stronger type system like Rust, F#, Scala, TypeScript.
Boring is better. Perfection is the enemy of good.
Go was designed as a systems language. They turned it into an applications language too, I'm guessing because turns out the greenthreading was uniquely good for that. But now it's awkward. The pointers and errors are not how you want an app lang to work. And LLMs struggle with error handling even more than humans.<p>Even as a systems lang, the error syntax is the worst part of Go. Can they at least put the ?/! syntax like in Rust instead of this "if err != nil" spam every other loc?
all my LLM coding is in go these days
In my opinion, the by far biggest problem Go has is called ...<p>Google.<p>Now one can say that a programming language and its design or
usefulness is - or should be - decoupled from the company
developing is. I am not opposed to this, in theory, but Google
goes way too much on my nerves these days. And I am hardly the
only one here.<p>I am not saying this is a rationale used by many other people
either, mind you, but Rust has been taking strides (not that I
am a huge fan of it either but for different reasons) and it
seems to me as if Rust has finally now more momentum than Go,
which I find interesting. Again, this may be a correlation
rather than any causation, but I can not help but notice it.
i thought we all landed on Python.
brb, rewriting backend
Rust is better. It just is. Go is not bad. But as a long time go advocate, the hurdle for my teams using rust is gone, and thus everything is now rust.
Personally I find Rust a lot harder to read than Go.<p>If you're going to have an agent write most of your code readability is very important.
I'll qualify this from my POV (which may be different than GP's).<p>Go's historic maintainability strong suit has been its simplicity and consistency. The syntax is, relatively speaking, lightweight, the language invites complexity through composition, and information density for any unit of code is typically quite low (which isn't necessarily a bad thing).<p><i>In my opinion,</i> though, these are all drawbacks, and Rust addresses all of them. It's syntactically and semantically much heavier, leading to its oft-maligned steep learning curve. It has, uniquely among the major languages, I think, a syntax for expressing variable lifetimes (with its own unintuitive semantics). It stuffs lots of abstraction into a hodgepodge of terse semantics and punctuation.<p>It sucks to read, until you get really used to it. Then it tends to read <i>really quickly,</i> and, at least for me, it's easier to reason about a conceptually-broad piece of logic if I don't have to jump between different locations in a file, a module, or a package to do it.<p>With Go, I find it more difficult to get into a flow state, and easier for my eyes to glaze over when looking over large diffs.<p>It's not lost on me that these are purely subjective arguments, though. My preference remains with Rust, and that goes back to before I used LLMs.<p>I'm also aware that Go is very prescriptive about how you write it; it's explicitly opinionated, and Rust doesn't have that. It means that most Go code bases will look more alike. I consider this an anti-feature; I believe code should be able to conform to the problem space or product and a good team will find the best way to do that.
Yeah, Go is easy to read in the same sense that English limited to its ten hundred most common words is easy to read (<a href="https://xkcd.com/1133/" rel="nofollow">https://xkcd.com/1133/</a>). Whether that nature is helpful or harmful to LLMs is an interesting question.
It seems very obviously detrimental to me (in the exact same way it's detrimental to people); e.g. use proper jargon with an LLM and you find it is suddenly an expert. The LLM has no trouble at all perfectly fluently using macros or monads or whatever thing people are afraid of to write simpler, more concise code that directly expresses the business logic in a fully type safe, high performance way that the compiler can introspect for even more information. Go of course lets you do none of those things and can only ever be used for "beginner code" by intentional design.
For whatever reason, maybe not even logical ones, Go repulses me. I don't know why exactly, I like the <i>idea</i> of Go, but the aesthetics rub me wrong.<p>I think it's the use of pointers and "if err != nil {}" error handling spam. It reads as a highly compromised imitation of Python and C rather than a solid execution of some other idea.<p>Rust is not the most beautiful language out there but it doesn't trigger any such reaction for me. The ? operator and "match", which I use constantly, more than compensate for some of the sigil noise which I barely need to look at much less write most of the time. So Rust wins on that comparison for me.<p>The "func name() -> retval" syntax also grew on me. I like the fact that Python type annotations copied that approach, and C-style declarations look ugly to me now. Same with C-style /* */ comments.
Because Go is kind of a Steampunk design. The creators collectively ignored decades of PL developments. What that nets is kind of a C without sharp edges, but can't be used where C can.<p>Rust is definitely jarring to look at, in the same way that decoding some strange C declaration can be, in ye olde days when you had to float all this context in your mind while doing work. But with modern tooling who cares: "explain this lifetime to me"
For me it's mainly the if err != nil {} stuff and the fact that everything is package scoped (C-style enums and constants).<p>You can pretty clearly see the limitations if you read, for example, the type of code the Protobuf compiler generates when trying to compile Protobuf/gRPC enums or structs into the way-more-limited Golang type system (this is despite the two being designed to work together). And it could <i>really</i> do with algerbraic data types and other modern programming language features.<p>Also the type system does have a couple weird behaviors that seem straight out of JavaScript. Like the difference between struct and interface nil for example:<p>```<p>var buf *bytes.Buffer = nil<p>var out io.Writer = buf // now out is nil<p>if out != nil {<p><pre><code> // This block will execute because out is not nil
out.Write([]byte("crash")) // This line will crash because out is nil
</code></pre>
}<p>```<p>Many things about the language almost seem to be designed to simplify the implementation of the compiler rather than to benefit the developer experience.
It's a matter of expressiveness, Rust expresses more.<p>E.g. make a table that's 3x3 is easier to read (Go), but the equivalent line in Rust would also include material, angles, height, etc. because the type system encodes much more information.<p>Though I always found Go to be significantly harder to read than Rust. Sure Rust has some crazy syntax at the edges, but Go makes it very hard to know where imports come from (and thus what they do), and the imperative style + lack of clarity about mutability makes code much harder to reason about.
Counterpoint: I find Rust easier to read.
Might be unpopular, but agents write too much code for humans to read in any meaningful time frame. Using agents to generate code to then require humans to slowly consume it defeats a lot of the speed you gain from AI.<p>I my self and teams members are slowly reading less code and requiring agents to prove things work the way we want in other ways.
I have an agent read most of the code as well. The agent explains things to me in plain english.<p>The default sentiment is humans should read code it's more progressive and a leap of faith to start giving that up.<p>Obviously, I get why you feel humans still reading code is important, but if you look at the progress of AI for the past couple of years, that gap is closing. The trendlines speak of a future where it becomes less and less important.<p>This was exactly what happened with writing code. Now most people don't write code.
> Now most people don't write code.<p>I use LLM daily to write code for and "with" me, I also write code without LLM. Most people I come across mix it up. A few do it all by hand, and equally few all by LLM I would say. Is that just in my corner of the world?
The trendlines are moving away from this. It's all happening so fast that not every company is on the same page, but from what I see we are quickly converging on not writing anymore code.<p>My entire company for example does not write a line of code. We manage agents and that's it. Many, many, many companies and people are already doing this.
I have a few utility go codebases that I simply do not read at all - but it's internal tooling so there's literally no point in reading it when the LLM can modify it in seconds to do new things.
I don't read all of the code produced by my agents any more, but I like to reserve the ability to do so if I run into a particularly confusing bug, or for any code that's security adjacent.
Personally, Rust or Typescript both happen to be better than Go for me. TypeScript has better type-safety and tooling for user-facing apps, and Rust has better type-safety and tooling for algorithmic stuff or stuff that needs to run fast.
I guess the difference in compile times doesn't matter enough?
idk. In my experience the build/compile experience has been far worse esp for fast iterating. Even concurrency models did not seem as intuitive as Go's. Im no systems expert - have deployed practical and performant distributed systems though.
Zig seems to have more closely aligned with what Go devs prefer.
Go doesn't have memory safety issues because of its GC, while Zig has UB problems. Zig might have slightly better performance, but I don't think choosing a language without memory safety is a good idea
Ignoring performance for the moment (because most situations are bottlenecked on something else), why is rust better?
I agree, but this doesn't justify anything. Saying rust is better because it "just is" won't convince anyone. I'd like to know why you think it's better.
can you elaborate?
except Rust is HARD while GO is super easy.
Rust makes you solve many of your problems upfront, which is a nice feedback loop for using with an LLM. Go does much of this too, but I feel Rust is more experessive and takes the frontloading a bit further.
It's not that hard.
“…requires opinionated simplicity…”<p>Of course it can’t just be simplicity, it has to be “opinionated” simplicity. Rolls eyes.
lol "Why Go is really good - an article by Google"
Let me share a hot take. I am deliberately taking this somewhat to the extreme, so please attack the idea not the person. Looking for thoughtful replies and good counterpoints, rather than language zeal.<p>Let's assume that you need to write a program with a given set of requirements, and that you have a magic wand that can instantiate a high quality implementation of the program in any programming language instantaneously and for free. My hot take is that you would not want to choose Go, and you would likely want to choose Rust.<p>The Go implementation will have higher memory and CPU consumption due to garbage collection, while still being subject to memory bugs. The Rust implementation would be as efficient as possible on the given hardware with minimum memory/CPU, and it would be immune to memory bugs.<p>In my view, the biggest challenge with Rust, and where Go wins, is the relative difficulty of writing in Rust as the language is significantly more complex. With LLMs this is becoming a non-issue, and we are getting ever closer to having this magic wand (I'd argue that for smaller programs the wand already exists today). The article advocates that Go has excellent readability. I agree that Go has trivial syntax, but given that it's so verbose, I actually find it easier to read Rust code. Its higher expressivity allows you to see the higher level intention of a piece of code more easily.<p>Many of the other benefits the article mentions for Go are equally applicable to Rust: compiler error messages are super detailed and a great help to coding agents, auto-formatting, a great language server, and a package ecosystem.
I agree all in all.<p>I guess from a pure language POV, one might argue that rust leaves humans with more opportunity to add abstractions that are too clever and too hard to wrap your head around. That doesn't feel like a strong argument, though.<p>Then there is of course the ecosystem, where go maybe has better libraries for some stuff (while rust may have better ones for other things).
If you are going to take the human out of the loop you could just write the program in assembly or machine code directly.
Because Go is an absurdly verbose language that hates to the core the idea of expressivity because it prides itself on being dumb.
[flagged]
[dead]
[flagged]
[flagged]
[dead]
[dead]
[dead]
[dead]
[dead]
Nice try