New junior developers can’t code

Recurring “kids these days” vs real changes

• Many see the article as part of a long tradition of older developers lamenting juniors, similar to complaints about Google, Stack Overflow, Python, IDEs, GUI builders, etc.
• Others insist “this time is different”: LLMs don’t just abstract detail, they can do most of the thinking and production for you, which feels qualitatively new.
• Meta‑debate: some argue “people always said this” is used to dismiss any criticism; others counter they’ve seen multiple generational cycles and recognize the pattern of overreacting.

AI vs traditional abstractions (compilers, SO, GPS)

• One camp equates LLMs with compilers, calculators, WYSIWYG, RAD tools, Stack Overflow: another step up the abstraction ladder.
• The opposing view stresses key differences:
  • C/compilers have a clear, inspectable, deterministic mapping to machine code; LLMs are statistical black boxes.
  • Prompts aren’t stably tied to outputs; small prompt changes can radically change code, making reasoning and debugging harder.
• Determinism via temperature=0 is noted, but critics say this sacrifices the main benefits and is rarely used in practice.
• GPS analogy: some say reliance is fine and expands what you can do; others argue navigation (fixed goal, fixed graph) is unlike programming (combinatorial design space, long‑term maintainability).

Learning, understanding, and the “ladder” of coding

• Several commenters outline a “ladder”:
  1. Design algorithms from first principles.
  2. Implement from a textual description.
  3. Adapt existing implementations (classic junior level).
  4. Copy–paste or accept LLM suggestions with minimal changes.
  5. Full “agents” (Cursor/Windsurf) that edit codebases semi‑autonomously.
• Concern: many new devs may stall at rungs 4–5, gaining skill at prompting rather than understanding code, which could erode the pool of future seniors.
• Compared to Stack Overflow, AI is seen as more passive: SO snippets typically needed manual integration, reading, and reconciling conflicting answers; IDE‑integrated LLMs can be accepted by pressing Tab.
• Some argue AI can be a deep learning aid (ask it to explain every line, cross‑check models), but that requires unusual discipline and motivation.

Workplace dynamics, hiring, and career pipeline

• Some think market forces will filter out “prompt‑only” devs; others worry that in 5–10 years there’ll be a shortage of experienced engineers who really understand systems.
• Seniors describe frustration with juniors who respond to code review by pasting LLM‑generated fixes, and with senior managers doing the same and pushing low‑quality “AI patches.”
• There’s debate over how much CS degrees matter: many list practical engineering skills (debugging, reading docs, choosing tech, working with people) that aren’t taught formally and may not be learned if AI handles too much.

Evolution of abstraction and what “coding” means

• Historical arc laid out: from machine code → compilers → libraries → frameworks → CRUD scaffolding → front‑end frameworks; each layer captured prior hard‑won knowledge.
• AI is seen by some as the next “knowledge capture” step, assembling and adapting solutions from the global corpus rather than just from APIs and libraries.
• One question: if AI makes CRUD and glue code trivial, where is the next frontier of “hard” knowledge—formal specs, verification, lower‑level systems, or something else?

Broader social / generational concerns

• Side debate over whether current youth are objectively worse off: some cite delayed adulthood, mental health meds, fitness and military eligibility; others point to lower crime, fewer teen pregnancies, and changing vices (screen time, games, porn).
• Consensus in that subthread is unclear; several note that statistics can cut both ways and the causal story is contested and emotionally charged.

Optimism: augmentation and new kinds of contributors

• Some seniors report huge personal gains: faster unblocking, exposure to new patterns, more fun side projects, and renewed motivation.
• Others see a positive shift where designers, PMs, and non‑technical staff can now meaningfully contribute code or data work, reducing bottlenecks and improving product outcomes.
• View that good juniors—those who are curious and self‑driven—will use AI as a multiplier, not a crutch; uninterested people were always going to be mediocre, with or without AI.