The L in "LLM" Stands for Lying

TL;DR Highlight

LLM-generated code and content is fundamentally 'forgery' — and we've lost something real by abandoning craftsmanship in favor of velocity.

Who Should Read

Developers wrestling with questions of craft, ownership, and quality in an era of AI-generated code, and tech ethicists thinking about what we lose when we automate creative work.

Core Mechanics

The core argument: when LLMs generate code, they produce outputs that mimic the surface form of expert work without the underlying understanding — this is forgery in a meaningful sense.
Craftsmanship involves not just the output but the learning process: struggling with a problem, developing intuition, building a mental model. LLM-generated code skips all of this.
There's a distinction between 'using AI as a tool' (like using a compiler or a library) and 'using AI as a substitute for thinking' — the author argues much current LLM coding use falls into the latter.
The velocity gains from AI code generation may be real short-term, but compound into skill atrophy and reduced understanding of systems you nominally own.
This isn't a Luddite argument — the question is about intentionality: are you using AI to go faster on understood problems, or to avoid understanding problems?

Evidence

The author drew on examples from their own experience of shipping AI-generated code they didn't fully understand, and the subsequent debugging costs when things broke.
HN had a typically spirited debate — with strong voices on both sides. Senior engineers shared experiences of losing juniors who could ship features but couldn't debug or reason about systems.
Counter-argument: craftsmanship in software has always been about outcomes, not process. Using better tools (including AI) is how craft evolves.
Several commenters noted the parallel to calculators in math education — we made a collective decision that computational fluency was worth trading for deeper arithmetic understanding.

How to Apply

Be intentional about when you use AI for code generation: use it for boilerplate and patterns you already understand, not for core logic you're still learning.
After AI generates code, make it a habit to read and understand every line before merging — not just 'does it pass tests' but 'do I understand why it works.'
For engineering leads: evaluate AI tool usage not just by velocity metrics but by whether your team's understanding and debugging capability is growing or atrophying over time.

Terminology

CraftsmanshipIn software, the ethic of deeply understanding what you build — not just making it work, but knowing why it works and caring about its quality.

Skill atrophyThe gradual loss of a skill through disuse — here referring to programming and debugging ability declining when AI handles too much of the cognitive work.