Control the Ideas, Not the Code
Large language models are enabling some developers to offload most coding to AI agents and focus instead on architecture, specifications, and testing, raising the provocative claim that reading every line of code is becoming “pointless.” Commenters weigh this against persistent issues of hallucinations, subtle bugs, codebase bloat, and long‑term maintainability, arguing that traditional practices like code review, refactoring, and careful testing are still essential. The thread also explores what this shift means for training new engineers, the quality of future training data, and the economics and ethics of AI-assisted open source development.
LLMs as Coding Agents vs Reading Code
- Many agree LLMs are now strong coding assistants and can handle large refactors, new modules, and unusual stacks when used well.
- Others report that as projects grow (100k–1M LOC), models drift, duplicate concepts, and gravitate toward popular frameworks and idioms, ignoring bespoke architectures or AGENTS.md-style docs.
- Some argue the future emphasis should be on “controlling ideas” (architecture, interfaces, tests) rather than reading every line of code; others find that reviewing at least some code is still essential to understand and guide systems.
Code Quality, Slop, and Scaling
- Several commenters see LLM-produced codebases as bloated, repetitive, and prone to concept drift, especially without strong conventions, linting, and human refactoring.
- Others claim success on sizeable Rust/Lua projects with guardrails, strong typing, and aggressive refactoring/testing.
- There’s concern that as AI-generated repositories dominate training data, future models may degrade due to lower “entropy” and feedback loops of mediocre code.
Skill, “Skill Issue,” and Teaching
- One camp attributes poor outcomes mainly to user skill in “agentic engineering” and experimentation.
- Others criticize this as arrogant and unhelpful, stressing that LLM workflows are new, under-documented, and hard to transfer without close collaboration.
- Debate centers on whether problems are “skill issues” or “knowledge/experience issues,” and whether experts have an obligation to share practical workflows.
Testing, Safety, and Reliability
- Broad agreement that models still hallucinate and overstate correctness; rigorous tests, TDD, property-based testing, and reproducible repro cases remain crucial.
- Some argue tests and empirical QA can largely replace code reading; others insist tests can never prove absence of bugs and that structure must be understood.
Licensing, Redis/Valkey, and Hyperscalers
- Side thread: strong disagreement over whether Valkey “replaced” Redis vs simply gained adoption, and whether this is due to licensing, not AI usage.
- Intense criticism of hyperscalers for profiting from open source without contributing proportionally, and debate over whether permissive licenses were a mistake.
- Some see “fair source” / open-core licenses as necessary defenses; others worry this undermines portability and self-hosting.
Careers, Learning, and Access
- Concern that if coding is delegated to LLMs, newcomers will struggle to build the mental models needed for architecture and design.
- Some fear a future where meaningful software work requires paid access to proprietary models and expensive hardware, making the field less accessible.
- Others advise ignoring influencers, continuing to write and read code, and treating AI as a powerful but fallible tool rather than a replacement.