The LLM Critics Are Right. I Use LLMs Anyway

Scope of Critique vs. Use

• Many commenters agree key LLM critiques (hallucinations, skill atrophy, centralization, environmental cost, ethics) are valid yet still use LLMs heavily.
• Others argue it’s not contradictory to use a flawed tool if you keep its limits in mind; critics and users aren’t disjoint groups.
• Some see blanket dismissal of LLM output as “slop” as denial of current capabilities; others see uncritical enthusiasm as equally biased.

Skill Atrophy and Knowledge Depth

• Strong concern that offloading “lower-level” work (coding details, regex, debugging) will erode fundamental skills and architectural judgment over years.
• Counter-argument: we’ve always abstracted away layers (calculators, compilers, cloud); only a minority really needs deep low-level skill.
• Several report already noticing weaker recall and retention when relying on agents; some deliberately keep hobby projects LLM-free to “exercise” their own skills.
• Debate over whether high-level design can be done well without low-level understanding; examples of “systems engineers” and AI users producing incoherent architectures.

Productivity, Quality, and Verification

• Reports range from “no net gain” (time spent reviewing cancels generation gains) to “~1.5–2x individual productivity” to “team output up ~25% after layoffs.”
• Research cited suggests developers systematically overestimate gains; team-level uplift is modest and often eaten by overhead or extra experiments.
• Gains are very context- and quality-bar dependent: LLMs shine when “slop is fine” or for boilerplate; can slow you down for high-quality, safety-critical work.
• Many say developers “cash in” gains as less burnout or more side projects, not more corporate output.
• Shared view: trust and review matter more than whether code is AI-authored. Small, test-backed diffs are manageable; huge agent-generated changes are not.

Testing, Code Review, and Agents

• Concern that LLM-written tests can be trivial yet produce impressive coverage numbers, giving false confidence.
• Some use LLMs effectively to generate or refactor test suites, but emphasize human review and stronger metrics than line/branch coverage.
• Agents can produce structurally messy codebases even if local snippets are OK; responsibility for architecture and constraints remains with humans.

Juniors, Mentorship, and Open Source

• Worry that replacing “junior tasks” with agents harms training pipelines and long-term code quality.
• Open source maintainers report a surge of low-quality, AI-written PRs, often harder to review than writing the fix themselves, leading to more gatekeeping.
• Others note LLM-assisted coworkers sometimes submit more idiomatic code that actually reduces review load.

Cognitive and Societal Effects

• Fears that pervasive LLM use will homogenize writing and thinking, similar to how platforms shape culture; others see them as just another tool extending “common sense.”
• Some use LLMs as tutors and interview-prep partners and report genuine learning benefits.

Ethics, Environment, and Token Use

• Moral objections focus on data provenance, corporate behavior, and environmental impact; using LLMs despite this is acknowledged as dissonant.
• Debate over carbon cost: some claim daily token use is minor vs commutes/food; others emphasize aggregate data center growth and projected AI energy share.
• Large token spends (e.g., ~$10k/month) are polarizing: some see waste or misuse of agents; others compare favorably to the cost of another engineer.