Pains

Product teams want higher-level abstractions and self-service capabilities for infrastructure provisioning. Many teams are adopting CDKTF or building internal platforms to bridge the gap, indicating Terraform's abstraction layer is insufficient for modern development velocity.

Unused or outdated resources like Deployments, Services, ConfigMaps, and PersistentVolumeClaims accumulate over time since Kubernetes doesn't automatically remove resources. This consumes cluster resources, increases costs, and creates operational confusion.

Heavy reliance on Terraform modules and resources specific to particular cloud providers can create inadvertent vendor lock-in, making migration between providers difficult and expensive.

Terraform can build secure, repeatable infrastructure landing zones, but cannot automate all required components like identity, pipelines, and secrets management, leaving gaps in the automation model.

Using Terraform workspaces to manage multiple environments (dev, staging, prod) requires heavy use of count parameters and conditional expressions, making code difficult to read and understand. Scaling across environments becomes increasingly complex as interconnections multiply.

Complex Terraform deployments with modules, multiple environments, split state, and orchestration tools like Terragrunt create challenging issues that require structured planning and disciplined workflows.

AI agents lack contextual understanding needed for long-form content and domain-specific nuance, reducing their effectiveness in handling complex scenarios that require deep understanding of broader context.

When implementing observability in Go, developers generate massive volumes of data (trillions of requests) that must be filtered and managed. Telemetry costs and data quality issues remain persistent problems despite tuning efforts.

Developers struggle with prompt composition strategies, variable injection, chat templating, deterministic output control, and managing memory/context windows across multi-step agent interactions. This represents 17% of agent development issues.

New team members spend days or weeks learning project-specific implementations of common patterns before becoming productive, significantly impacting project timelines and team productivity.

Misconfigured Kubernetes affinity rules cause Pods to schedule on incorrect Nodes or fail to schedule at all. Affinity configurations support complex behavior but are easy to misconfigure with contradictory rules or impossible selectors.

37% of developers familiar with SIMD have been impacted by Go's absence of native SIMD support. 17% report being limited in the performance they can achieve in their projects, and 15% had to use another language instead.

58% of teams report challenges identifying performance issues in running Go programs, and 57% struggle with identifying resource usage inefficiencies.

Despite being a hallmark of Go, channels are slow and throw away language niceties like defers and interface indirection when optimizing for performance. Developers must abandon many of Go's features to achieve high performance.

Go struct literals appear suitable for config parameters but provide no compiler enforcement for required fields. Omitting mandatory fields compiles without error, leading to silent bugs at runtime.

Error handling depends on matching error message strings, which are not compiler-enforced. When package authors change error messages, downstream error handling logic breaks silently with no compile-time protection.

AI agents continuously poll for changes instead of being notified of events, wasting compute cycles and increasing latency. Moving to event-driven patterns requires architectural redesign.

Overusing goroutines leads to excessive context switching, performance degradation, and memory waste. 10,000 goroutines can consume 20+ MB of memory with overhead, and the Go scheduler incurs penalties causing throughput to halve.

Channels are frequently misused for synchronization tasks better handled by function returns or shared memory. 60% of Go applications experience performance degradation from deadlocks, and indefinite blocking on channels causes goroutine leaks.

33% of Go developers struggle to ensure their code follows idiomatic patterns and best practices. Developers switching between Go and other languages face cognitive load, and many request official guidance and tooling support to enforce idioms.

Go lacks default implementations for common interfaces and relies on runtime reflection to handle operations like printing structs or maps, which sidesteps the type system entirely. This creates ad hoc, edge-case-laden behavior.

Go has an extensive list of subtle gotchas and counterintuitive behaviors across data structures, concurrency primitives, JSON handling, and more (e.g., nil interfaces vs nil interface values, closed channel panics, unexpected range clause behavior). These are documented in community resources but create a steep learning curve.

Many AI agents cannot operate autonomously and require continuous human oversight, preventing full automation and limiting their practical value for scaling operations.

Redis does not natively support advanced features like joins, aggregations, full-text search, time-series data management, or graph processing. This limits use cases to simpler key-value and caching scenarios, blocking applications requiring sophisticated data processing.