AI doesn't generate working products, that's still your job
AI tools are making it dramatically faster to go from idea to first working prototype, but many engineers argue they do little to shorten the harder journey to reliable, maintainable, “production-grade” software. Commenters describe AI-generated code as useful raw material or a “supercharged IDE” for small apps and experimentation, yet often messy, incoherent, and hard to evolve at scale without strong human architecture, testing, and domain expertise. Underneath this lies a broader anxiety: the industrialization of software development, shifting skill requirements, and uncertainty over whether AI will mostly augment developers, deskill them, or eventually displace entire roles.
Scope of AI’s Help: Prototype vs. Production
- Broad agreement that AI greatly accelerates going from nothing to a first working version.
- Many argue it does not similarly shorten the path to “production‑grade”: battle‑tested, maintainable, well‑understood by a team, and robust across edge cases.
- Others push back: if coding time is 10× faster, later stages must also benefit. Counter‑argument: user feedback, requirements discovery, and trade‑off decisions are the real bottlenecks, not typing code.
What “Production‑Grade” Means
- Described as:
- Surviving real users’ complaints, edge cases, and changing needs.
- Reflecting a shared mental model of the system within the team.
- Being maintainable without constant surprises or regressions.
- AI‑generated code often looks fine locally but yields globally incoherent architectures over months: subtle design drift, over‑complexity, and hard‑to‑reason systems.
Code Quality, Slop, and Maintenance
- Many report:
- AI is excellent for happy‑path CRUD apps, internal tools, and “throwaway” experiments.
- Long‑lived or complex systems degrade when largely steered by agents; AI is good at adding code, bad at removing/cleaning it.
- Repeated “find and fix issues” loops can create endless churn: fixing and re‑breaking different parts.
- Others say average micro‑level code quality across industry has improved thanks to better patterns, linters, and AI‑assisted bug fixing, but macro‑level coherence remains a challenge.
How People Use AI Effectively
- Successful patterns:
- Treat AI as a very fast assistant or “code monkey”: humans do architecture, domain modeling, and test design; AI writes most implementation.
- Require explicit plans first, then stepwise implementation and rigorous testing (unit, integration, property checks).
- Use smaller/weaker models for tight, interactive assistance instead of fully agentic “let it run” workflows.
- Failure patterns:
- One‑prompt‑per‑PR “vibe coding” without deep review.
- Non‑engineers shipping AI‑generated systems they don’t understand, then expecting others to “productionize” them.
Jobs, Roles, and Methodology
- Fear centers less on individual skill and more on:
- Fewer roles needed for the same output.
- Erosion of the traditional “craft + methodology” identity of software engineers.
- Several argue we need new methodologies for AI‑scale codebases (e.g., more formal methods, algebraic data types, stronger verification), not just old practices with “AI” swapped in.
Impact on Products and the Economy
- Disagreement on visible impact:
- Some see a surge of new (especially niche) tools, notably in areas like healthcare and internal SaaS.
- Others note a flood of low‑effort apps, worsening UX, and few obviously transformative end‑user products.
- Overall: AI clearly boosts code output and prototyping; whether it’s yet delivering correspondingly better products and durable systems is contested and largely viewed as unresolved.