Ask HN: What are your current programming pet peeves?

Hacker News Discussion ↗

Documentation, Search, and Learning Curve

  • Strong frustration that in 2025 it’s still hard to find clear docs for basic features; search is dominated by SEO farms, AI sludge, bootcamp blogspam, and outdated answers.
  • Python splits opinion: some say the built-in help() and official docs are excellent once you learn their structure; others find them dense, spec-like “walls of text” and want concise quick-reference tables instead.
  • PEPs are praised as good references but criticized as serving as de‑facto user docs.
  • Similar issues in other ecosystems (Ruby, Free Pascal/Lazarus): official docs often only list arguments without explaining meaning, use, or design.
  • W3Schools/GeeksForGeeks are called out as high-ranking but shallow and incomplete; MDN-style docs are considered far more informative.
  • Frequent complaint about libraries lacking READMEs that explain audience, context, and realistic examples.
  • Several people wish API docs explained high-level design and rationale, not just tautological method descriptions.

Shells, Terminals, and Tooling

  • One thread laments that shells still look the same and asks for a Python-like shell experience.
  • Others defend traditional shells (bash/zsh/fish) as better suited for process orchestration and pipelines than Python; Python as a login shell is described as clumsy.
  • Alternatives like xonsh and nushell are suggested as “Python-ish” or more structured shells.
  • Debate over whether using a shell counts as “programming.”

Churn, Deprecation, and Ecosystem Instability

  • Major peeve: libraries/frameworks constantly deprecating APIs; even projects untouched for months feel “ancient,” especially in NPM/Node ecosystems.
  • Old browser JS still works, but modern build chains (Gatsby/Node) often won’t build without painful upgrades.
  • Complaints about moving targets in both tech and product requirements; developers feel forced to chase shifting APIs and specs.
  • Monorepos are said to complicate documentation and deployment, requiring extra tooling layers.
  • Some want drastic simplification (e.g., dropping legacy x86 modes).

Types, Config, and Abstraction Choices

  • Static typing sparks strong disagreement:
    • One side finds complex type systems overbearing and misaligned with how they think and work.
    • Others say most bugs in dynamic-language codebases are effectively type errors and prefer static or gradual typing.
  • Preference expressed for inferred, non-ornate type systems (Hindley–Milner-like) over “do everything in the type system” designs.
  • Frustration with poor domain modeling: objects full of optional fields, or logic expressed via untyped hash maps/dicts and YAML configs.
  • YAML DSLs in particular are criticized as fragile, hard to tool, and harder for LLMs to handle compared to real scripting languages.

AI, Code Generation, and Developer Experience

  • Mixed views on LLMs:
    • They’re seen as useful for navigating bad documentation, dependency hell, and obscure errors.
    • But AI-generated code from colleagues is described as overengineered, subtly buggy, and poorly understood by its “authors.”
  • Some argue AI should focus more on reviewing human code than generating it.
  • Worry that improving public docs just feeds training data; predictions of more paywalled/“paid web” content.
  • Annoyance at AI tools that don’t auto-retry failed requests and that lag behind current language versions.

Product Websites, Process, and Social Frictions

  • Strong irritation with developer-product sites aimed at executives: buzzwords instead of clearly stating “what it does” and “what it costs.”
  • Dislike of being forced to provide contact info to get technical details, which signals an unpleasant sales funnel.
  • Complaints about bug reporting: project-specific trackers, rigid templates, and stale bots closing issues. Idea floated for an independent, cross-product bug tracker curated by users.
  • Social/process peeves dominate for some: moving requirements, pressure to estimate and then compress timelines, and being responsible for both defining and building evolving products.

Miscellaneous Pet Peeves

  • Odd indentation widths; unpleasant large legacy C codebases with nonstandard styles and heavy macro/makefile usage.
  • Git is seen by some as overcomplicated and overdue for a more intuitive replacement; alternatives like fossil and jj are mentioned positively.
  • Node/JS ecosystem churn, function coloring, JS vs TS debates (with some asserting TS + LLMs is now the clear choice for serious work).
  • Complaints about debugging multiprocessing, opaque build systems (e.g., CMake), null-terminated strings, ambient-privilege OSes, fragile web-app build pipelines, AI service UX (e.g., Gemini quirks), and even specific syntax like elseif.