The 70% problem: Hard truths about AI-assisted coding

Original Article ↗ Hacker News Discussion ↗

AI coding assistants like Copilot and Claude are seen as powerful but unreliable tools that can quickly generate 50–70% of an implementation, yet still leave the hardest 30–50% — architecture, edge cases, debugging, correctness, and maintainability — to experienced engineers. Commenters argue this amplifies senior developers’ productivity while risking shallow understanding among juniors, raising concerns about how the next generation will learn fundamentals and how hiring pipelines might change if “easy” tasks are automated away. Many compare the current hype to past waves of 4GLs and low‑code tools: useful for boilerplate and exploration, but no substitute for human judgment, deep domain knowledge, and rigorous validation.

Impact on junior developers and learning

  • Many fear juniors will rely on AI to “paste code that works” without understanding it, slowing their path to senior-level skills.
  • Others argue juniors can still learn by debugging AI-written code, similar to learning from bad Stack Overflow snippets.
  • A recurring concern: AI reduces opportunities for mentorship and may shrink the pool of experienced developers in 5–10 years.
  • Some see AI as an always-available tutor that can accelerate learning for motivated juniors, especially if used to ask “why” questions, not just to generate code.

Code quality, verification, and the “70% problem”

  • Common experience: AI can produce working scaffolding or 70–90% solutions, but fails on tricky logic, edge cases, architecture, and non-functional concerns (performance, security, accessibility).
  • Seniors report spending significant time refactoring, tightening types, adding tests, and removing redundant checks from AI code.
  • Trusting AI-generated tests or bindings without human-written specs is viewed as dangerous; tests may assert the wrong behavior.
  • Some advocate stronger use of property-based testing, static typing, and even formal verification, potentially aided by LLMs.

Productivity gains and their limits

  • Seniors often feel “dramatically faster” at boilerplate, cross-language tasks, and unfamiliar frameworks; juniors often get confused or misled.
  • AI excels at small, well-specified tasks (examples, APIs, “magical incantations”) and at explaining or transforming code.
  • For novel or complex systems, AI tends to loop, hallucinate APIs, or produce verbose, brittle solutions; 12-week projects don’t become 4-week projects, maybe 9–10.

Tools, UX, and integration

  • Chat-style interfaces and copy-paste are seen as major bottlenecks; deeper IDE integration (patch application, multi-file edits, context files like SPEC.md/LESSONS.md) is praised.
  • Some specialized tools (Cursor, Aider, etc.) partially address multi-file refactoring, but users still report friction, stuck agents, and deployment glitches.

Jobs, education, and long-term concerns

  • There is anxiety that AI will replace much “junior work,” reducing entry-level hiring and creating a future senior shortage.
  • University instructors report students overusing LLMs, failing to build foundational skills or even formulate questions.
  • Several see parallels to past hype cycles (4GLs, low-code, CASE tools): big boosts on “accidental complexity,” but essential problem-solving remains human.