Sources

The 2025 Go Developer Survey reveals developers' desire for better best practices, enhanced standard library usage, and modernized tooling. AI-powered development tools are common, yet satisfaction is moderate due to quality concerns. Most respondents are experienced developers in the tech industry, highlighting challenges like ensuring code quality and finding reliable modules. ### Key Points ... A major challenge for Go developers is identifying and consistently applying idiomatic best practices, along with finding trustworthy third-party modules. Use of AI-powered development tools is now common among Go developers, but overall satisfaction remains moderate due to concerns about code quality and reliability. … ... The **2025 Go Developer Survey** is out and it offers a clear snapshot of where the Go ecosystem stands today and where friction remains. Developers broadly value Go as a stable, productive platform, but they are asking for more guidance on **best practices**, better ways to **leverage the standard library**, and **modernized tooling** to reduce day-to-day friction. AI-powered development tools are now widely used among Go developers, particularly for learning, boilerplate generation, unit tests, and autocompletion. However, satisfaction remains moderate. The dominant concern is **code quality**: AI-generated output often requires careful review, corrections, and contextual adjustments, which limits trust and caps productivity gains. AI is seen as helpful for reducing toil, not as a reliable autonomous coder. The survey highlights a recurring usability issue with Go's tooling: **core command documentation**. A significant number of developers report frequently revisiting documentation for fundamental commands such as `go build`, `go run`, and `go mod`. The current help system is functional but not discoverable or ergonomic enough - this is what the data suggests. … Three challenges dominate developer feedback: - Difficulty identifying and enforcing best practices. - Missing language features commonly found elsewhere, particularly around **error handling**, **enums**, and expressiveness. - Trouble identifying **trustworthy third-party modules**, with developers asking for stronger quality signals, maintenance indicators, and usage context. … 28 % Percentage of respondents frustrated by missing language features found in other languages. 26 % Percentage of respondents reporting difficulty finding trustworthy Go modules. 53 % Percentage of respondents using AI-powered development tools daily. 29 % ... 55 %

As we move through 2025, the software development landscape continues to evolve rapidly. Technologies like microservices, cloud-native applications, and distributed systems are becoming the standard. ... ## The Challenges of Plain Go in 2025 While Go still has significant strengths, using plain Go without any frameworks presents several challenges in the modern development landscape, especially for more complex applications. ### Increasing Complexity of Modern Applications In 2025, even a simple microservice may need to integrate with multiple dependencies to meet production standards. These might include tools for distributed tracing, metrics collection, circuit breaking, and various communication protocols. Managing these integrations manually in plain Go often results in significant boilerplate code and a higher maintenance burden. |Challenge|Plain Go|Frameworks (e.g., GoFr)| |--|--|--| |Integration|Manual|Built-in integration of logging, tracing, and messaging| |Code Redundancy|High|Low (predefined patterns)| |Maintenance|High|Low (centralized updates)| ### Reinventing Common Patterns Without frameworks, developers often find themselves reimplementing common patterns and solutions to recurring challenges. This might include setting up logging, configuring middleware, implementing health checks, or managing database connections. Such redundant work can slow down development and introduce inconsistencies across projects. ### Onboarding and Knowledge Transfer In today's competitive job market, the speed at which new team members become productive is crucial. With plain Go, developers may spend days or even weeks learning the project-specific implementations of common patterns before they can contribute effectively. This extended onboarding process can negatively impact project timelines and team productivity. … The question isn't whether plain Go is viable—it absolutely is for many use cases. The real question is whether your team can afford the overhead of manually integrating and maintaining numerous dependencies and reimplementing common patterns across services. For teams building complex, distributed systems, frameworks like GoFr provide a compelling balance of productivity and performance. The ideal approach may be a pragmatic one: use plain Go where its simplicity and performance are paramount, and leverage frameworks like GoFr where productivity and standardization matter most.

However, like any programming language, Go has its set of limitations as of 2025. ... Despite the introduction of generics in recent updates, some developers find Go’s implementation lacking in comparison to other languages like Java or C#. The complexity of using generics and limited syntactical sugar might slow down its adoption a**** Go veterans who have grown accustomed to the idiomatic way of writing Go code. As of 2025, Go still lacks a standard library for GUI development. While there are third-party solutions available, they often lack the integration and comprehensive documentation needed for seamless development, which can be a hindrance for projects aiming for cross-platform graphical user interfaces. Error handling in Go has been a topic of debate due to its verbose nature. Using `if err != nil` after every function call can lead to less readable code, making error management cumbersome for developers. While Go’s explicit error handling promotes clear understanding of error flows, it can be considered a limitation in terms of code succinctness and elegance. Go’s design philosophy emphasizes simplicity and readability, but this also means it has limited support for metaprogramming. Features like reflection are available, but they are not as powerful or easy to use as in languages like Python or Ruby. This limits dynamic code generation and runtime behavior manipulation, which are essential for certain types of applications. Although improvements have been made with modules, developers in 2025 often find Go’s package management lacking compared to more mature ecosystems like Node.js with npm or Python with pip. The inclusion of better dependency handling and version conflict resolution tools could significantly enhance the developer experience. While Go continues to be a powerful tool for a variety of applications in 2025, these limitations should be taken into consideration when choosing the right technologies for your next project.

### Lack of generics Generics are well supported by a wide range of languages, and is one of the most requested lacking features of Go. The usual response from the Go authors is that implementing generics will either slow down compilation, the code, or the programmer. While that is almost a believable reason, the funnier part of their reasoning is (excerpt from FAQ): … #### Flow disruption Perhaps the most elusive, but rather destructive aspect of the lack of generics in Go is how the language forces the user to go into uninteresting details while expressing ideas, disrupting the programmer’s flow. We don’t have to venture far to see examples of this - we can stay at the topic of list operations, as we did in the previous example. … #### Lack of deriving Default implementations for certain interfaces should be provided. How can Go print out our structs or maps correctly? We don’t know. It is done with reflection, which is runtime concept and sidesteps the type system entirely. The ad hoc, edge case laden nature of Go shows here again. For those who are unfamiliar with the concept: … ### Other minor annoyances #### General inelegance ##### Superflous syntax Almost everywhere superflous brackets of all types can be found. What is the purpose of: vs (hypothetical Haskell equivalent) ? Go got rid of some of these (for loop, if requires no parentheses), but there are still plenty. ##### Operators should be functions The only reason operators are not functions is because the type system is not sophisticated enough to describe them.

- Opening Brace Can't Be Placed on a Separate Line - Unused Variables - Unused Imports - Short Variable Declarations Can Be Used Only Inside Functions - Redeclaring Variables Using Short Variable Declarations - Can't Use Short Variable Declarations to Set Field Values - Accidental Variable Shadowing - Can't Use "nil" to Initialize a Variable Without an Explicit Type - Using "nil" Slices and Maps - Map Capacity - Strings Can't Be "nil" - Array Function Arguments - Unexpected Values in Slice and Array "range" Clauses - Slices and Arrays Are One-Dimensional - Accessing Non-Existing Map Keys - Strings Are Immutable - Conversions Between Strings and Byte Slices - Strings and Index Operator - Strings Are Not Always UTF8 Text - String Length - Missing Comma In Multi-Line Slice/Array/Map Literals - log.Fatal and log.Panic Do More Than Log - Built-in Data Structure Operations Are Not Synchronized - Iteration Values For Strings in "range" Clauses - Iterating Through a Map Using a "for range" Clause - Fallthrough Behavior in "switch" Statements - Increments and Decrements - Bitwise NOT Operator - Operator Precedence Differences - Unexported Structure Fields Are Not Encoded - App Exits With Active Goroutines - Sending to an Unbuffered Channel Returns As Soon As the Target Receiver Is Ready - Sending to an Closed Channel Causes a Panic - Using "nil" Channels - Methods with Value Receivers Can't Change the Original Value - Closing HTTP Response Body - Closing HTTP Connections - JSON Encoder Adds a Newline Character - JSON Package Escapes Special HTML Characters in Keys and String Values - Unmarshalling JSON Numbers into Interface Values - JSON String Values Will Not Be Ok with Hex or Other non-UTF8 Escape Sequences - Comparing Structs, Arrays, Slices, and Maps - Recovering From a Panic - Updating and Referencing Item Values in Slice, Array, and Map "for range" Clauses - "Hidden" Data in Slices … - Blocked Goroutines and Resource Leaks - Same Address for Different Zero-sized Variables - The First Use of iota Doesn't Always Start with Zero - Using Pointer Receiver Methods On Value Instances - Updating Map Value Fields - "nil" Interfaces and "nil" Interfaces Values - Stack and Heap Variables - GOMAXPROCS, Concurrency, and Parallelism - Read and Write Operation Reordering - Preemptive Scheduling - Import C and Multiline Import Blocks - No blank lines Between Import C and Cgo Comments - Can't Call C Functions with Variable Arguments … ###### Built-in Data Structure Operations Are Not Synchronized - level: beginner Even though Go has a number of features to support concurrency natively, concurrency safe data collections are not one them :-) It's your responsibility to ensure the data collection updates are atomic. Goroutines and channels are the recommended way to implement those atomic operations, but you can also leverage the "sync" package if it makes sense for your application.

| Navigation Search|## Go teams struggle with coding standards – survey Thursday January 2, 2025. 07:37 PM , from InfoWorld Although developer sentiment toward the Go language remains very positive, teams face a challenge when it comes to maintaining consistent coding standards across Go code bases, according to Go developer survey results for the second half of 2024. Go developers also have been quick to adopt AI assistants, the survey found. The survey, conducted from September 9 through September 23, found that 93% of respondents felt satisfied working with Go during the prior year. Maintaining consistent coding standards, though, was a challenge due to team members having different levels of Go experience and coming from different programming backgrounds. This has led to inconsistencies in coding styles and adoption of non-idiomatic patterns. Published December 20, 2024, the survey covered a total of 4,156 responses, with participants recruited from the Go blog and randomized prompts in the Go plugin for Visual Studio Code and the GoLand IDE. ... In other findings in the survey: 70% of respondents were using AI assistants when developing with Go. The most common uses were LLM-based code completion, generating Go code from natural language descriptions, writing tests, and brainstorming. The survey found a significant discrepancy between what respondents said they wanted to use AI for last year and their current use for AI.

The most common use of AI in Go software that includes AI features is summarization (45%), followed by classification (33%) and generation (32%). When asked whether they were satisfied with the use of AI tools in software development, 13% answered satisfied, 42% answered mostly satisfied, 22% answered neutral, 16% answered mostly dissatisfied, and 7% answered dissatisfied. … When asked whether they were satisfied with the Go language, 91% answered yes. However, only 25% of respondents said that the Go language contribution process was easy for them to understand, and only 28% said that the Go language project's leadership in responding to questions was good, indicating that the Go language project still has some issues to address.

Let us find the core reasons why the hype of Golang has been flattered in 2025. In contrast, Rust and Kotlin offer the power and flexibility needed for real-world complexity without sacrificing safety or performance. This is one reason why big techs are losing interest in Golang. Rust’s memory management model, which avoids runtime GC altogether, is gaining traction where performance and predictability matter most. This hostile and complex system makes Golang a least decided language in the programming world. … ## Reasons for Golang losing its relevance in 2025 ### 1. Simplicity that doesn’t scale The core process of Golang has always been its simplicity. But in 2025, scalable software development requires more than for-loops and manual boilerplate. Go language still lacks essential features like pattern matching, powerful generics, and rich abstractions, which modern developers expect. In contrast, Rust and Kotlin offer the power and flexibility needed for real-world complexity without sacrificing safety or performance. This is one reason why big techs are losing interest in Golang. ### 2. Painful Error Handling The complex pattern remains a hallmark of Go programming but is now widely viewed as outdated in the tech world. While languages like Rust use elegant error propagation and TypeScript provides structured error handling, Golang developers are stuck repeating verbose error checks. This has led to fatigue and decreased productivity in large codebases. ### 3. Concurrency without safety Yes, goroutines impacted practice, but they are critical without proper safeguards. Orphaned routines, race conditions, and deadlocks are all too common. Meanwhile, Rust concurrency provides compile-time guarantees, making it the preferred choice for big tech firms prioritizing safety and performance. ### 4. Garbage collection isn’t cutting it In 2025, latency-sensitive environments like high-frequency trading or real-time analytics can’t afford the unpredictability of Go’s garbage collector. Rust’s memory management model, which avoids runtime GC altogether, is gaining traction where performance and predictability matter most. This hostile and complex system makes Golang a least decided language in the programming world. ### 5. Lack of modern ecosystem support Despite efforts, Golang WebAssembly (WASM) support remains half-baked. In contrast, Rust and TypeScript dominate in the WASM development arena. The lack of powerful IDE support, modern tooling, and language features has left Go programming looking like a relic.

- **Results from the 2025 Go Developer Survey**: 5,379 Go developers responded, reporting high satisfaction with Go and its tooling, with common pain points including understanding best practices, missing features, and evaluating trustworthy third-party modules (plus a look at AI tool usage).

We use Go *because it’s boring*. Previously, we worked almost exclusively with Python, and after a certain point, it becomes a *nightmare*. You can bend Python to your will. You can hack it, you can monkey patch it, and you can write remarkably expressive, terse code. It’s also remarkably difficult to maintain and slow. I think this is characteristic of statically and dynamically typed languages in general. Dynamic typing allows you to quickly build and iterate but lacks the static-analysis tooling needed for larger codebases and performance characteristics required for more real-time systems. In my mind, the curve tends to look something like this: … ### The Untype System To put it mildly, Go’s type system is impaired. It does not lend itself to writing quality, maintainable code at a large scale, which seems to be in stark contrast to the language’s ambitions. The type system is noble in theory, but in practice it falls apart rather quickly. Without generics, programmers are forced to either copy and paste code for each type, rely on code generation which is often clumsy and laborious, or subvert the type system altogether through reflection. … The argument there, I suppose, is to rely on interfaces to specify the behavior needed in a function. In passing, this sounds reasonable, but again, it quickly falls apart for even the most trivial situations. Further, you can’t add methods to types from a different (or standard library) package. Instead, you must effectively alias or wrap the type with a new type, resulting in more boilerplate and code that generally takes longer to grok. You start to realize that Go isn’t actually all that great at what it sets out to accomplish in terms of fostering maintainable, large-scale codebases—boilerplate and code duplication abound. It’s 2015, why in the world are we still writing code like this: Now repeat for uint32, uint64, int32, etc. In any other modern programming language, this would get you laughed out of a code review. In Go, no one seems to bat an eye, and the alternatives aren’t much better. … Another idiosyncrasy is adding an item to a channel which is closed. Instead of returning an error, or a boolean, or whatever, *it panics*. Perhaps because it’s considered a programmer error? I’m not sure. Either way, these behaviors seem inconsistent to me. I often find myself asking what the “idiomatic” approach would be when designing an API. Go could really use proper algebraic data types. … In actuality, to write high-performance Go, you end up throwing away many of the language’s niceties. Defers add overhead, interface indirection is expensive (granted, this is not unique to Go), and channels are, generally speaking, on the slowish side. For being one of Go’s hallmarks, channels are a bit disappointing. As I already mentioned, the behavior of panicking on puts to a closed channel is problematic. What about cases where we have producers blocked on a put to a channel and another goroutine calls close on it? They panic. Other annoyances include not being able to peek into the channel or get more than one item from it, common operations on most blocking queues. … But upon closer inspection, we realize this approach is subtly broken. While it works, if we stop iterating, the loop adding items to the channel will block—the goroutine is leaked. Instead, we must push the onus onto the user to signal the iteration is finished. It’s far less elegant and prone to leaks if not used correctly—so much for channels and goroutines. … ### Dependency Management in Practice For being a language geared towards Google-sized projects, Go’s approach to managing dependencies is effectively nonexistent. For small projects with little-to-no dependencies, *go get* works great. But Go is a server language, and we typically have many dependencies which must be pinned to different versions. Go’s package structure and *go get* do not support this. Reproducible builds and dependency management continue to be a source of frustration for folks trying to build real software with it. … A few other technical points: – “Cannot add methods to types from a different package”: Would you want something like extension methods in C#? – “Channels are slow”: I’ve read there is some work going on to improve them. That said, you admit yourself that Go is still one the best option among the “concurrent” languages. Are you aware of another language with a similar mechanism builtin in the language or the library and that performs better on this matter?

Begin by utilizing Go's powerful type system effectively. Research shows that approximately 30% of runtime errors in programming stem from type mismatches. Leveraging Go's static typing can significantly reduce these issues, leading to more robust code. Embrace type assertions and interfaces judiciously to ensure clarity in your data structures. Next, prioritize concurrency management. A staggering 50% of developers express difficulties with Goroutines and channels. Misuse can lead to race conditions or deadlocks. Familiarize yourself with tools like the Go race detector to identify and troubleshoot concurrency issues before they escalate. … ## Common Go Developer Pitfalls for Beginners & How to Avoid Them Avoiding the misuse of Goroutines is key. It’s crucial to understand that overusing them can lead to excessive context switching and performance degradation. According to Google’s Go Blog, proper concurrency patterns can improve performance by nearly 30%. Always utilize synchronization methods like WaitGroups and Channels to control Goroutine lifecycle effectively. Another critical aspect is error handling. Many early coders overlook error checking, resulting in silent failures. Statistics show that 59% of Go developers face this issue. Always return errors to the caller and handle them appropriately. Implementing proper logging practices helps to trace issues when they arise. Understanding the type system is vital. Newcomers might incorrectly assume that all Go types behave the same. This misunderstanding can lead to unexpected behavior, especially when using maps and slices. Always refer to official documentation, as 42% of new users struggle with type assertions and conversions. Another factor to consider is dependency management. Not using Go modules can complicate project portability and dependency retrieval. According to the Go community survey, 37% of developers use vendoring, which can cause compatibility issues. Always maintain consistent version control with Go modules to ensure reproducibility. … |Issue|Statistic|Recommendation| |--|--|--| |Misuse of Goroutines|30% performance improvement with proper patterns|Use WaitGroups and Channels| |Error handling|59% face issues due to neglect|Always check and log errors| |Type system confusion|42% struggle with assertions|Consult official documentation regularly| |Dependency management|37% use vendoring|Utilize Go modules for version control| |Neglecting tests|50% do not write tests|Implement unit tests with the ‘testing’ package| … |Problem|Solution| |--|--| |Too many goroutines consuming resources|Implement a worker pool to limit concurrency| |Performance degradation under load|Use tools like pprof for monitoring| |Race conditions in data handling|Leverage channels for safe communication| … - **Memory Impact:** Running 1,000 goroutines could consume 2 MB of memory, while 10,000 could use up to 20 MB with additional overhead. - **Context Switching:** The Go scheduler incurs a penalty with significant context switching; even a modest increase can halve throughput. For lightweight tasks, consider using channels or worker pools. This can help manage concurrency without the downsides associated with an excessive number of goroutines. … ### Inappropriate Use of Channels Utilize channels in Go with clear purpose and structure. Misusing them can lead to deadlocks and performance issues. Always assess whether a channel is necessary or if a simpler approach, such as using goroutines or shared memory, is more suitable. Channels should not be used for tasks that could be handled by simple function calls. For example, using a channel to pass error messages instead of returning errors can complicate code and decrease readability. Statistically, 75% of Go developers prefer returning errors directly in most synchronous cases. Blocking calls on channels may introduce latency. If a goroutine waits indefinitely for a message that will never arrive, this can lead to a deadlock scenario. Implement timeouts using the `select` statement to prevent such situations. |Channel Usage Problem|Recommended Approach|Key Statistics| |--|--|--| |Deadlocks from improper synchronization|Implement timeouts and context-based cancellation|60% of Go applications face performance degradation due to deadlocks| |Unnecessary complexity in code|Use direct function returns for computations|80% of developers find simpler code easier to maintain| |Excessive channel creation|Reuse channels where applicable to minimize overhead|Channel creation can increase resource consumption by up to 30%| … ### Mismatching Error Types in Interfaces Avoid implementing interfaces with mismatched error types. In Go, it's essential to define error handling clearly. If an interface expects a specific error type, returning a different one can lead to panic situations or unexpected behavior. Stick to consistent error types across your application. Consider defining a custom error type that implements the built-in … method with %w to wrap errors, preserving their original type and context. **Data Point:** According to a recent survey by Stack Overflow, 45% of Go programmers find unclear error handling a significant issue, emphasizing the need for straightforward practices. Always ensure that your error messages contain actionable information that helps diagnose the problem. Avoid abstract descriptions, which can lead to confusion and increased resolution time.

## Terraform in practice We’ve worked with and spoken to platform teams at fast-moving startups, growing mid-size orgs, and multi-cloud enterprises. They all use Terraform and have built internal tooling, standards, and CI pipelines to manage it. And almost all of them still have the same problems: drift, copy-paste modules, fragile reviews, broken dependencies, unclear ownership, and too much tribal knowledge. … ## Problem 1: Terraform is deceptively simple “I just need to provision an S3 bucket and an IAM role. Shouldn’t take more than 10 minutes.” – Famous last words from a junior engineer Terraform starts easy. But what you see is only the top of the HCL iceberg. You write a few resources. Then you need a backend. Then providers. Then variables. Then modules. Then environments. Then workspaces. Then you realize the code is the easy part, and the real complexity is in understanding *what this code will actually do in the real world.* … ## Problem 2: Everyone’s Terraform is different! The beauty of Terraform is its flexibility. The curse of Terraform is also its flexibility. Every company has its own flavors: - Custom modules with their own naming patterns, output conventions, and hidden assumptions - Some teams use `terraform apply`; others have 8-step CI workflows - Some apply per environment, some per resource, some per team - Half the team uses Terragrunt (wrong), the other half doesn’t (also wrong) … ## Problem 3: Drift is inevitable The moment your infrastructure touches the real world, it starts to drift. → An engineer fixes something manually in the AWS console. → Someone disables a policy to unblock a deploy. → An external system updates a tag. → A resource gets destroyed and recreated with new defaults. You run `terraform plan` and it looks fine — because Terraform only knows what *you* told it. It doesn’t know about the out-of-band changes. It doesn’t warn you that a resource has drifted. It happily wipes out your fix and calls it “safe.” … ## Problem 4: The plan looks fine. Until it isn’t. Terraform plans are supposed to bring safety and predictability. In theory, you see what will change before it changes. In practice: You scroll through hundreds of lines, looking for anything suspicious, hoping nothing sneaky gets through. The plan tells you *what* will change. It rarely tells you *why.* It doesn’t tell you what modules depend on this. It doesn’t tell you which services this IAM policy might break. It doesn’t tell you this change will wipe out and recreate a stateful database. … Helpful. You trace through nested modules, try to remember if that variable is a string or a map, and mentally reconstruct the dependency tree. You check the state. You re-run the plan. You eventually just `console.log` your way through `terraform console`. Terraform doesn't make debugging easy. It makes you guess. ## Problem 6: Infra review doesn’t scale In theory, Terraform should enable fast, safe infra changes. In practice, infra PRs sit for days because: - No one has enough context to approve them confidently - Everyone is afraid of breaking something - The person who owns the module is on PTO - The plan is massive, and no one wants to read it The result? You either block product teams or approve blindly. Neither is good. Both are common. ## Some things we haven’t even mentioned yet We haven’t talked about: - Plan noise from computed diffs - Implicit vs. explicit dependencies - Hidden resource recreation - Conditional logic that breaks silently - The tension between DRY and readable code - Running `terraform destroy` in the wrong workspace 😬 ## A better way? If you’ve read this far, you’re probably not surprised by any of this. You’ve lived it. Terraform gives you control, but it doesn’t provide you with confidence. Not when drift is invisible. Not when context lives in someone’s head. Not when reviewing a plan feels like decoding a black box. Infra isn’t hard because we’re doing it wrong. It’s hard because the workflows weren’t designed for how teams actually build and ship today: fast-moving, multi-owner, highly parallel, deeply interconnected.