Going full AI engineer, not touching code anymore
Claims that software engineers can now “go full AI” and stop writing code themselves draw starkly mixed reactions. Many see large language models as powerful accelerators for boilerplate and MVPs, but warn that over-reliance risks eroding core coding skills, narrowing solution spaces, encouraging mediocre architectures, and confusing probabilistic outputs with compiler‑like determinism or reliability. Others argue that the real value in engineering is problem framing, architecture, and judgment rather than typing, yet even they stress the need for rigorous review, accountability, and hands‑on practice to avoid long‑term technical and organizational debt.
Skill Atrophy and Understanding Code
- Many worry that “not touching code” will erode the ability to program and reason about systems; reading diffs alone may not be enough practice.
- Some argue long experience and continual code review will preserve skills; others note managers who stopped coding did lose technical sharpness.
- Concern that relying on LLMs early in problem‑solving narrows one’s solution space and trains people into “mid” thinking.
LLMs vs Compilers and Determinism
- Multiple commenters reject the analogy “LLMs are like compilers”: compilers are deterministic translations with clear semantics; LLMs produce best‑guess, sometimes wrong, designs.
- LLM output is seen as closer to an intern’s work: sometimes helpful, never fully trustworthy, always requiring review.
Speed, Business Incentives, and Quality
- Strong theme: businesses optimize for velocity and short‑term revenue. LLMs fit this by enabling fast, cheap MVPs whose hidden 5–15% of problems show up later.
- Quality and long‑term maintainability are often deprioritized; LLMs may accelerate creation of fragile, Rube Goldberg codebases.
How People Actually Use LLMs for Coding
- Experiences diverge: some get high‑quality, idiomatic code routinely; others find LLMs verbose, brittle on complex tasks, and slower than hand edits for small changes.
- Common pattern: humans design architecture and core abstractions, then use LLMs to fill in boilerplate or extend patterns.
- LLMs often struggle with refactoring, larger OOP systems, reuse of existing utilities, and avoiding duplicated helper functions.
Impact on Design, Architecture, and Solution Space
- Advocates say the real value in software is architectural decisions and trade‑offs; LLMs free them from typing to focus on that.
- Critics counter that if you no longer build architectures yourself, you lose the tacit knowledge needed to judge them or foresee their long‑term costs.
Career Identity and Role Shift
- Some welcome becoming “AI orchestrators,” likening it to moving from manual craft to directing powerful tools.
- Others feel this is effectively sliding into management and away from the craft they enjoy.
- Broader worry that many are chasing AI hype, prompt tricks, and self‑promotion rather than doing solid engineering.