If you stop writing code, you also get worse at reviewing it
AI-assisted and agentic coding are raising concerns that developers who stop writing code by hand will lose the ability to deeply understand and review it. Commenters describe a tradeoff between massive speed gains and the atrophy of core skills such as architecture, debugging, and reasoning about systems, especially as organizations shift reviews toward higher-level design or offload them to AI. Some see this as an inevitable evolution of software engineering, while others fear a future of brittle, poorly understood systems maintained by people who can no longer reliably judge the quality of the code they ship.
AI-generated code and self-degrading feedback loops
- Several commenters fear a “ouroboros” effect: AI replaces human coders, reducing the supply of high-quality training data and degrading future models.
- Concern that the biggest AI users are orgs with poor, misunderstood codebases; high-quality teams may avoid sharing code or even open-sourcing, skewing data toward “slop.”
- Some foresee deliberate lock‑in: binary-only distribution, legal/technical barriers to using open models, and “farming” user dependency.
Skill atrophy: writing vs reviewing code
- Strong agreement that if you stop writing code, your ability to review, debug, and reason about it decays—analogies to pilots mandated to fly manually or musicians who stop practicing.
- Others argue reviewing and writing are distinct skills; some people are good at one but not the other, though many say real mastery of review requires active coding.
- Several note a paradox: to use LLMs effectively you must already know the domain, but heavy reliance risks eroding that knowledge over time.
How people are using agents in practice
- Common pattern: offload “boring” or repetitive code to agents, then do careful line‑by‑line review, especially on critical or long‑lived systems.
- Some restrict agents to small, incremental changes; others “vibe engineer” entire features with minimal review, trading quality for speed and volume.
- A minority admit they rarely read AI code anymore, focusing on business rules, data structures, and security, and trusting automated checks.
Changing nature and value of code review
- Many lament that thorough human review is already rare; where it exists, it’s valued for shared understanding, team alignment, mentoring, and architectural correctness.
- Some argue code is now “cheap” but architecture, interfaces, and tests are not; reviews should move up in abstraction rather than disappear.
- Others think AI + strong automated verification will make manual review largely obsolete, especially as AI improves at both writing and reviewing.
Learning, expertise, and future developers
- Several worry that juniors who never build systems “by hand” won’t develop deep mental models, only shallow familiarity with generated solutions.
- Others report learning more, faster, by using LLMs as tutors, experiment enablers, and exploration tools—but acknowledge that “reading” solutions is less sticky than solving problems oneself.
- There is unresolved tension between enthusiasm for massive productivity gains and fear of long‑term loss of human expertise and explainability.