Pains

React Server Components (RSC) create confusion about client-server boundaries, increase development complexity, and introduce latency. Simple applications feel overengineered due to RSC requirements, creating a steep learning curve and performance concerns with cold starts on serverless platforms.

Gemini CLI unintentionally outputs file contents and changed file versions before applying edits, creating excessive chat spam. This causes severe scrollback/buffer bloat, especially on window resize, making the interface unusable and obscuring meaningful interactions.

Unit tests fail during setup (broken dependencies, missing object properties) rather than at assertions. PyTest cannot run tests after dependency refactoring, delaying detection of actual logic bugs.

uWSGI completely demised; Gunicorn losing async workload share; ASGI servers (uvicorn, Hypercorn) replace WSGI. Rust-based alternatives (Granian) emerging, fragmenting tooling ecosystem and forcing framework migrations.

Developers face high costs when using flagship OpenAI models like GPT-5, especially at high volume usage, making cost management a significant concern for production applications.

Using thrown errors as stand-ins for expected error handling makes types non-exhaustive and unclear about what can go wrong. Try-catch blocks are scattered throughout implementations and not all thrown errors are caught correctly, leading to hard-to-follow error management patterns.

Developers frequently forget to implement type guards or narrowing for union types, resulting in runtime errors when accessing type-specific properties or methods. This requires checking the actual type before using type-specific operations.

Not all JavaScript developers are comfortable with static typing, causing companies to face longer and more expensive hiring cycles when seeking developers proficient in both Node.js and TypeScript. This skill gap increases recruitment friction during team growth.

TypeScript does not allow developers to import modules with explicit .ts extensions, unlike standard ECMAScript/JavaScript practices. This forces module resolution traversal which is particularly slow over networks, and contradicts TypeScript's own design where the team knows .ts files must be transpiled to .js anyway.

TypeScript's extensive type features encourage developers to overuse strict mode, union types, type assertions, and complex type definitions, which actually increase code complexity without reducing bugs or improving readability. This represents a fundamental DX problem where the language design incentivizes anti-patterns.

The TypeScript configuration file has numerous options that are overwhelming and intimidating for developers to configure properly. This creates a barrier to correctly setting up TypeScript projects.

Many third-party JavaScript libraries lack proper TypeScript type definitions, forcing developers to either use `any` types or write their own type definitions. This creates friction when integrating external dependencies.

TypeScript's typing system, including concepts like generics, utility types, and complex type inference, is difficult for developers to learn and use properly. The complexity of understanding advanced typing patterns creates a significant barrier to entry.

26% of developers struggle with task planning and resource allocation. Container users specifically need better tools for task planning (18%), yet existing solutions don't adequately address this need.

The transition from the Pages Router to the App Router has been controversial. Many developers found the Pages Router intuitive and straightforward, but the newer App Router introduces additional complexity that some argue is unnecessary for most applications.

Next.js middleware has significant limitations, including a single middleware file requirement and complex chaining patterns that make routing and request handling difficult compared to traditional frameworks.

Free GitHub-hosted runners perform 4-5x slower than comparable local hardware (e.g., i7-13700H mini-PC). This forces teams running Jenkins locally to accept longer build times (30 min to 40 min) even after parallelization, impacting developer velocity.

Container users need better monitoring/logging tools (16% request improvement), but existing solutions don't provide adequate observability for non-local distributed environments.

Working with JSON data in PostgreSQL requires special operators and functions that are difficult to use, especially with nested structures. While JSON saves time and space, querying it is error-prone.

60% of respondents employ multiple ingress controllers, adding operational complexity and potential inconsistency in application networking configuration and management across clusters.

More than 25% of developers report Kubernetes has made cost management worse, 13% cite worsened security posture, and 15% report hindered architectural refactoring. Kubernetes provides scalability and HA benefits but creates new problems in these critical domains.

83% of developers run Python versions 1+ years old despite containerization making upgrades trivial. Missing out on 11-42% performance improvements (3.11→3.13/3.10→3.13) and 10-30% memory reductions without code changes.

Python scripts written without discipline grow unwieldy and difficult to maintain. Historic cross-implementation compatibility breaks regularly, causing pain. Refactoring becomes risky without strong static analysis.

Despite Python's automatic memory management, developers encounter memory leaks and inefficient memory usage patterns. The lack of explicit control over memory allocation/deallocation makes it difficult to identify and fix memory-related performance issues without specialized profiling tools.