Lessons for Agentic Coding: What should we do when code is cheap?

Original Article ↗ Hacker News Discussion ↗

As large language models and “agentic” coding tools make it dramatically cheaper and faster to generate code, software engineers are debating whether this is a genuine productivity breakthrough or a path to fragile, unmaintainable systems. Many argue that while prototypes and small features are now almost free, the real bottlenecks have shifted to specification, architecture, verification, maintenance, and product prioritization — and that code remains a long‑term liability even if it’s cheap to write. Others raise broader concerns about hollowing out junior roles, overreliance on external AI vendors, and management expectations that collapse delivery timelines without accounting for debugging, security, and long‑term support.

Job Market and Skills Pipeline

  • Many report junior hiring collapsing, especially in India; internships and entry roles in frontend, devops, and sysadmin are harder to get.
  • Concern that skipping a generation of juniors will cause long‑term “brain drain”: seniors leave or retire, juniors move to other industries, and expertise is lost.
  • Some argue this is a tragedy-of-the-commons problem: any single company “doing the right thing” on junior hiring can’t fix industry‑wide dynamics.
  • Others counter that automated dev systems will just keep improving, so demand for traditional developers may not return.

Capabilities and Limits of Agentic Coding

  • Enthusiasts say latest frontier models make it viable to “let rip”: many more features, high test coverage, detailed tickets/docs, and multiple streams in parallel.
  • Skeptics say LLM code is verbose “slop,” often 90% plausible but only ~50% correct; fixing it can take longer than writing it by hand.
  • Several stress that LLMs are good at local changes and boilerplate but bad at managing complexity, architecture, and long‑term design without strong human guidance.
  • Some see them as excellent for refactors, tests, and internal tools; most are wary of using agents uncritically for production systems.

Code Cost, Maintenance, and Tech Debt

  • Repeated theme: “code is a liability.” Cheap generation doesn’t make maintenance, debugging, support, or security cheap.
  • Fear of “instant legacy” systems: vibe‑coded, under‑documented, indispensable, and unfixable by either humans or AI.
  • People expect software volume and tech debt to pile up as making more code becomes trivial, especially if incentives favor feature count over quality.
  • Others argue cheap code reduces the cost of “doing it right” (better patterns, refactors, tests) if teams deliberately invest in quality.

Tooling, Process, and Verification

  • Agent harnesses and tools (IDE integration, planning systems) get mixed reviews: they can enforce planning and best practices, but may add overhead.
  • Common advice: tighten specs, do TDD, add multi‑stage checks (plan → design → code → tests), and invest in end‑to‑end and boundary verification.
  • LLMs help with code review, but can’t replace careful human reading; many examples where subtle bugs, performance issues, or over‑engineering slipped through.

Economic and Platform Dynamics

  • Thread references “no moat”: cheap open‑weight models are considered close to state‑of‑the‑art and expected to keep improving.
  • Others note big labs still have growing revenue; longer‑term profitability and true cost (subsidies, future pricing) are seen as unclear.
  • Companies worry about dependence on external APIs: price risk, geopolitics, and unannounced model changes, which pushes interest in open‑weights and self‑hosting.

Management, Prioritization, and Culture

  • Several say the true bottleneck is deciding what to build, not how to code it. Cheap code exacerbates weak prioritization and “build everything” pressure.
  • Reports that leadership now questions engineer estimates using their own AI-produced plans, compressing timelines and eroding trust in expert judgment.
  • Concern that engineers are treated more like interchangeable task executors or “managers of agents,” and that expectations (features per person) are becoming unrealistic.
  • Some see a widening gap between “AI haves” (who redesign workflows around agents) and “have-nots”; others think overall impact in large enterprises may remain modest due to organizational bottlenecks.