What are your current programming pet peeves?
Perhaps someone could point out a solution or discussion could inspire someone to create a solution.
I can't believe that in 2025 it is still hard to find documentation for basic functionality in languages as ubiquitous as, say, Python.
If I google something simple I get 100 junk sites of garbage (GeeksForGeeks, W3Schools, etc), a bunch of AI-generated crap, a bunch of archaic out-of-date stuff, the official documentation which is a wall of dense text, some tutorials that mention the basics, a bunch of shitty bootcamp blogspam (they make you write blog posts about crap to get your brand out there, you know), some stackexchange posts with twenty different answers from 2010, etc. And I'm thinking of, like, Python here, cause that's what was pissing me off this week. God help you if what you're looking for is made by Apple.
Sure we're using AI to look up documentation now but that should never have been necessary. Just like now we use AI to google things because google is so shitty. It's not that AI is great, it's that search engines and documentation are more dogshit than ever and AI is a bandaid.
also it is amazing to me that shells still exist in more-or-less the same form. dear god can I just get a terminal that runs something like Python directly?
The fact that most new programming services and products are oriented towards C-suite types, and not to the people who actually use them.
Most websites looks like [1] or [2] which are full of corporate-friendly buzzwords but don't help me understand what they actually do or how they work. To get a concrete understanding I need to go to github and find repos that actually use the product to even understand what it's for.
[1] https://www.astronomer.io/
[2] https://tailscale.com/
I’m pretty sick of the moving target that is Node and common build chains.
Stuff I wrote in Javascript/jQuery twenty years ago still works fine in the browser. Now I’ve got some Gatsby projects I built around 2019 and I can't deploy them due to various degrees of incompatibility with minimum versions of Node.
I get why, as a server platform, Node has to be improved to eliminate security holes. But for static site deployment, there ought to be some kind of stable foundation that will work forever; or, at least, build tools should be designed around the idea of stable Node features that won't deprecate or dissolve as the future marches on.
Currently, domain specific languages written in YAML. I see these everywhere, from configuring individual utilities to managing giant architectural stacks. People get in their heads that YAML is more easily written and read than code, and so instead of just writing the code to do something, users have to deal with a bunch of YAML.
The drawbacks of YAML have been well-documented[1]. And I think it's worse now in the LLM era. If I have a system that's controlled via scripts, an LLM is going to be good at modifying those scripts. Some random YAML DSL? The LLMs have seen far fewer examples, and so they're going to have a harder time writing and modifying things. There's also good tooling for linting and checking and testing scripts to ensure LLM output is correct. The tooling for YAML itself is more limited, even before getting into whatever application-specific esoteric things the dev threw in.
[1] https://noyaml.com/
Other people's AI generated code. They don't understand it, it's over engineered, it looks right at first glance but turns out to be full of subtle bugs. At least that's pretty much universally been my experience.
What could be done about it? Hard to tell. I think actually productive use cases of generative AI for software development exist, I spend a lot of time with Claude every day. But I don't generate code, examples maybe, mostly I use it as a first (but not only) tool for research.
I think a lot of tooling could be built around generative AI providing reviews for human code, rather than it generating code for humans to review.
I'm pretty confident we'll get to a good place with a set of good practices and good tooling. But right now, it's pretty terrible, and my only solution at the moment is to not work with anyone who AI generates code. Luckily I'm in a position to enforce that, not everybody is.
It’s frustrating to have to find the right place to report a bug, learn the specific format the project is expecting, then have the bug closed by a “stale bot” after a few weeks. I wish there were an independent, cross-product bug tracker that focused on cataloguing and diagnosing bugs for the benefit of users rather than on tracking work for the benefit of the developer.
Effort to get code running on my machine. There are hundreds of unique processes for any bit of code you find on Github.
In many (most?) ways things have gotten worse since the days of running make or an .exe.
Packages/frameworks/libraries deprecating features left right and center.
Tech is moving too fast to keep up, a project I worked on and haven't touched in months; NPM would make me feel it's ancient, ofc a lot of the updates are security patches and important, but more often than not it's just libraries trying to race other libraries building different (debatable) features.
When someone uses an odd number of indentation! That really grinds my gears for some reason.
Having used Scala and TypeScript a lot for work over the last ~5 years, I think I'm going to say static typing. It's lunacy. Computers mostly don't work in types, my brain usually doesn't work in types, and only a small subset of the problems I work on really work in types.
The amount of modern languages that think they can solve everything in the type system boggles my mind.
Lack of README files that explain the project, the audience, and provides some good examples.
Libraries that change their api surface so much over time that LLMs end up producing code against deprecated versions of the library. More up front thought should be given to the api surface.
I dislike the manufactured overcomplexity of web app development nowadays, especially in corporate environments. Maybe I'm just curmudgeonly, but all of that command-line building crap with frameworks and dependencies and auto-reloading browsers--I feel it adds a lot of work for little reward, and introduces a lot more opportunities for problems to arise. All I need is a good text editor and a browser with dev tools, thank you very much. Grumblescoff.
Cursor doesn't auto-retry my request, it presents me with a button to click to retry. If you know the request failed, you could just retry on my behalf!
I would say type signatures that don't really describe the state of the program. Especially when someone has objects with a bunch of optional fields that either shouldn't be optional or should be represented in a different way, like as a discriminant union.
Git. Having lived through many cycles of version control systems (VSS, SVN, TFS, Hg), this one has gone on long enough to be replaced with something more intuitive. I think a lot of project complexity is work arounds of inherent Git issues. But I'm just a caveman lawyer.
Function coloring. It's spreads like cancer amongst different programming languages and only a few are not infected yet. Clearly the 'goto' mistake of our decade!
Having to put contact information to get any technical info on a commercial product.
It tells me within 5 minutes that dealing with you is going to be a pain in the ass, so I'm unlikely to buy or pursue and I'll start looking for something else.
I don't want to be put in a sales funnel, not yet, I just want to be able to do some due diligence on my own for a little while.
Honestly, my biggest programming pet peeves are not really technical but social. Constantly working on moving targets, being responsible for both fleshing out and building these moving targets, having to estimate work and then being told that that takes too long, ...
Using JS instead of TS. Pre-LLMs it was way slower to write and debug complex types. Especially in startup environments it was not often worth it.
Nowadays in 2025 with LLM autocomplete in IDEs, TS is a joy, anyone not using it for anything serious just smells of plain incompetence
I am frustrated that the programming agents never seem to use the latest version of the languages (Go it seems to be multiple versions behind) or packages. This is especially annoying in front end.
IntelliJ (and other IDEs) have a funny workflow for generated code. I want to edit a .proto file and have it handled the same way editing a .java file is, but I have to build it Maven/Gradle.
"elseif", cannot stand that statement. Only know 1 other who hates it :)
Drop 32 bit, 16b modes and segments from x64 CPU's. If you must, maintain just one core fully x86.
Gemini has several fatal flaws (on Firefox):
- when enabling the Canvas the prompt scrolls to the first prompt constantly
- Canvas doesn't allow for browsing of the documents
- Ctrl+C doesn't copy, wtf?
- Gemini over eagerly edits Canvas documents, inserting errors and silly comments
- it has been doing this since forever.
Claude is the clear winner, but has tighter usage limits.
frameworks or languages deprecating apis.
monorepos complicate everything. documentation doesn't factor them in, deployment instructions don't factor them in. efficient deployment needs a whole additional framework on top. additionally AI also doesn't understand the combination of things, but when it does, a new major version of a framework has dropped and isn't in the training set.
I'm just venting because that's the prompt and I don't need a solution or rely on AI. but if someone does have solutions I guess I'm interested
Hash maps. Everyone just turns their brains off and uses hash maps for everything. The code this creates is awful for users, awful for people consuming it, awful for people maintaining it.
Think for five minutes about your abstraction and create meaningful types and config languages, don't just hack it with a hashmap.