Coding agents have replaced every framework I used

Original Article ↗ Hacker News Discussion ↗

Initial claim and reactions

  • The line “software engineers are scared of designing things themselves” is polarizing; some dismiss the article outright, others say it accurately describes big-company cultures where devs only “follow tickets” and design is centralized.
  • Many argue “software engineering never left”; what changed is tooling, not the nature of the work.

Frameworks vs AI‑generated custom code

  • Pro-article camp: frameworks (especially modern web stacks) add needless layers, solve problems most apps don’t have, and create new complexity; now that boilerplate is cheap, small bespoke stacks (plain HTML/JS, minimal frameworks, custom libraries) become viable again.
  • Opposing camp: frameworks encode hard-won domain knowledge, correctness, security patches, performance tuning, and a shared vocabulary. Replacing them with AI-written one-offs recreates old bugs, increases risk, and makes onboarding harder.
  • Some see a middle path: keep “foundational” abstractions (web standards, Rails/Django, LVGL, crypto libraries), but drop many thin glue libraries and overengineered stacks.

Code quality, correctness, and maintainability

  • Strong concern that AI-produced code is the “ultimate abstraction”: non-deterministic, origin-opaque, often duplicated and inconsistent across a codebase.
  • People report agents creating near-duplicate functions/classes, ignoring existing patterns, and drifting away from internal conventions.
  • Frameworks are defended as vehicles for correctness and security: they accumulate bug fixes over time, whereas AI-generated equivalents would each need rediscovering and patching.
  • Several predict a future “de-slopping” industry: consultants or tools cleaning up large AI-generated messes.

Productivity gains and limits of coding agents

  • Some report dramatic speedups on greenfield work, glue code, CI/debugging, OAuth integrations, Gradle configs, embedded drivers, etc.
  • Others find that any time saved on typing is lost in review, debugging, and regaining understanding; a few say projects would have finished faster if hand-coded.
  • Best results come from treating agents as junior collaborators: detailed plans, AGENT.md files, small iterative tasks, separate “review” agents, and heavy human oversight.

Learning, expertise, and the future of engineers

  • Worry: if juniors skip the “manual” phase, how will they build intuition about architecture, trade-offs, edge cases, and debugging?
  • Counterpoint: prior abstraction waves (assembly → C → high-level) provoked the same fears; most engineers don’t need deep low-level knowledge.
  • Broad agreement that architecture, domain understanding, and defining invariants remain the hard parts; AI shifts effort upward but does not remove that work.