When a developer Yash Batra chose Golang for an early-stage fintech startup, it felt like the right move. Golang, also called Go, was fast, modern, and battle-tested at Google, Kubernetes, and Docker. Six months later, however, he rewrote the backend entirely with Kotlin.
His recent blog, titled ‘I Picked Golang for My Startup—Biggest Mistake of My Life’, has since resonated with dozens of developers who once believed in Go’s promise, only to find that it didn’t live up to the hype. “Everything we built took twice as long. We weren’t creating value—we were building tools just to build tools,” Batra wrote.
“Go slowed us down, sabotaged our productivity, and nearly derailed our product vision…Go is your friend if you’re building the next Prometheus. But for startups? You’ll thank yourself for picking expressive tech,” Batra concluded.
Batra’s message is clear—Go is not the developer’s favourite language anymore. And there’s even more concerning evidence to back this up.
Ian Lance Taylor, one of the long-time maintainers of Go at Google, recently bid farewell to Google. But why? “Go has reached the status of being just another programming language,” Taylor said in his farewell note after leaving Google. “That is far beyond what any of us expected.”
Taylor emphasised that Go is far from finished and will continue to evolve. However, he also acknowledged that the programming environment has changed, and Go must adapt accordingly.
In today’s fast-paced product development environment, Go may be too low-level and rigid. Startups trying to move quickly often find Go’s minimalism more of a hurdle than a feature. Despite powering giants like Docker and Kubernetes, Go is no longer the rising star it once was.
It Gets a Lot Deeper
Go’s origin story is steeped in engineering excellence. It was developed in 2007 by Rob Pike, Ken Thompson, and Robert Griesemer at Google to simplify systems programming with strong concurrency support and a lean syntax.
There was a time when Go was hailed as “the C of the cloud”, a go-to language for infrastructure tools, networking applications, and cloud-native microservices. Its creators imagined a language that would do less but do it well. And it did—for a particular set of problems.
However, since 2022, as evident in a blog by fasterthanlime titled ‘Lies we tell ourselves to keep using Golang’, developers and companies have begun rethinking their relationship with the language, considering it a prototyping language or a good entry-level language.
The blog notes that many early adopters of Go, who championed its simplicity and concurrency, are now stepping away due to ecosystem limitations, hiring challenges, and poor ergonomics in AI workflows. Batra echoed similar concerns in another blog post, explaining why he will never use Go for machine learning workloads.
Why Developers are Moving On
The recent departure of Taylor from Google, along with a wave of blog posts like Batra’s, has sparked questions about Go’s future. An increasing number of developers are turning to languages like Kotlin, Rust, and even emerging ones like Zig, which offer more flexibility or modern features.
That said, it is important to note that not all of the criticism paints a complete picture. Go still has a dedicated fanbase, with supporters coming out in support of the language in comment sections. This clearly shows that the language is far from being dead.
However, some common frustrations persist. Go’s verbose error handling, requiring explicit error checks, often leads to repetitive and brittle code. Some complain about the poor ergonomics for asynchronous programming. While goroutines are powerful, they can introduce race conditions and silent failures. Testing such conditions remains a challenge, as many developers highlighted in a HackerNews discussion.
Go’s ‘no frameworks’ philosophy leaves developers spending cycles reinventing the wheel.
Hiring is also a common issue. According to recruiters, the talent pool for Go is smaller than that of Java, Python, or JavaScript. Onboarding new developers can also take longer due to missing abstractions, making it not a developer-friendly language.
Companies can’t find enough experienced Go developers, and mid-career engineers hesitate to invest time in a language with limited job opportunities. On top of that, AI tools don’t generate idiomatic Go code well, making languages like Python even more attractive in an age of AI coding.
Enter Zig, Kotlin, and Rust
Go’s simplicity once made it attractive to Python and JavaScript developers. Yet, many are now moving to Zig, which promises clean syntax and blazing performance without Go’s baggage.
Zig fans point out that the programming language compiles to native code, avoids garbage collection, and includes async/await support. Tools like Bun, a JavaScript runtime, and TigerBeetle, a distributed financial database, are already showcasing Zig’s potential.
Kotlin, on the other hand, wins with tooling. Its rich ecosystem—complete with powerful object-relational mapping (ORM), test suites, and Spring Boot integration—makes it easy to onboard and iterate. Rust continues to dominate in areas where performance and safety are non-negotiable, albeit with a steeper learning curve.
Niche, Not Dead
Despite the growing criticism, Go is thriving, particularly in the infrastructure and systems engineering space.
Go remains the language of choice for building cloud-native tools, lightweight APIs and internal tooling at large organisations. Many engineers argue that Go was never meant to be a rapid product iteration language like JavaScript or Ruby—it was meant to be boring, stable, and scalable.
“Go’s simplicity is its power, but also its curse,” one user noted on Hacker News. “It’s not trying to be Python. It’s trying to be reliable.”
As Taylor aptly said, “I don’t think that any programming language is ever done—the programming environment changes all the time, and languages must evolve or die.”
