A narrative has been building in the AI discourse lately: "LLMs may be good at coding, but code was never the hard part." The implication is that programming was always the easy bit, and the real value was in figuring out what to build, not how to build it.
This is a gross insult to every programmer who has ever poured years into mastering their craft. And it's also a dangerous narrative that could lead us to undervalue the skills that actually make software reliable.
The Claim
The argument goes something like this: AI can now write code, so the "coding" part of software development is becoming commoditized. But deciding what to code — the architecture, the product decisions, the user needs — that's still hard, and that's where humans will continue to add value.
It sounds reasonable. It's also wrong.
If Coding Is Easy, Why Has It Always Been Hard?
If coding is easy, how come programmers have been in high demand for decades? Why have they commanded large salaries even before the zero-interest-rate era? Why was there so much stress, overwork, and burnout in the profession?
If coding is easy, why are there doorstopper books like Clean Code and The Pragmatic Programmer? Is The Art of Computer Programming a light summer read? Is Structure and Interpretation of Computer Programs a coffee-table book? Why do we have bootcamps and four-year college degrees dedicated to it?
If coding is easy, was John Carmack just in the right place at the right time? Why do we consider Fabrice Bellard a genius?
If coding is easy, why are people angry when AI (or anyone else) copies their code? Why do they act like they've poured their sweat, soul, and copious amounts of time into something trivial?
If coding is easy, why do many programmers now feel like their identity and professional purpose are being stripped away?
If coding is easy, why is software so damn buggy?
The Hidden Complexity of Code
The truth is that "coding" — the act of writing code — involves an enormous amount of implicit knowledge and skill:
- Understanding edge cases: The difference between code that works in the happy path and code that handles every edge case is enormous. This is where bugs live, and it's where senior developers earn their keep.
- Performance: Writing code that works is one thing. Writing code that scales to millions of users, handles concurrent access, and doesn't eat all your memory is something entirely different.
- Maintainability: Code is read far more often than it is written. Writing code that other humans can understand, modify, and extend is a skill that takes years to develop.
- Security: As the recent OpenAI agent incident showed, even well-resourced teams can have security vulnerabilities. Good programmers think about security at every level.
- System design: Individual functions are easy. Systems of interacting components that remain reliable under stress are hard.
When someone says "code was never the hard part," they're typically thinking of the happy path — the straightforward implementation that works in the demo. But real software lives in the edge cases, the error handling, the race conditions, and the production failures.
What's Actually Happening
The narrative serves a purpose: it makes the displacement of programmers by AI feel less threatening. If coding was never the hard part, then AI replacing coding isn't really replacing the valuable part of the job.
This is comforting. It's also a form of denial.
What's actually happening is more nuanced:
- AI is good at generating code that works in the happy path: For straightforward implementations, AI is genuinely helpful. It can scaffold an API endpoint, write a test suite, or generate a UI component.
- AI struggles with the hard parts: Edge cases, performance optimization, security, system design — these are where AI still needs human oversight.
- The value of experienced programmers is increasing, not decreasing: As AI generates more code, someone needs to review it, understand it, and maintain it. The volume of code is increasing, but the capacity to evaluate it isn't.
The Real Hard Parts
If we're being honest about what's hard in software development, it's not just "figuring out what to code" vs. "coding." It's:
- Understanding existing systems: Most programming work involves modifying existing codebases, not writing new ones. Understanding a codebase you didn't write — its assumptions, its constraints, its technical debt — is genuinely hard.
- Debugging: Finding why something doesn't work is often harder than writing it in the first place. AI can help here, but it still requires human reasoning about system behavior.
- Tradeoffs: Every technical decision involves tradeoffs — performance vs. readability, speed of delivery vs. maintainability, simplicity vs. flexibility. Making these tradeoffs wisely is where experience matters most.
- Communication: The hardest part of many programming jobs isn't the code — it's understanding what stakeholders actually want, which is often different from what they say they want.
The Danger of the Narrative
The "code was never the hard part" narrative is dangerous because it:
- Devalues programming expertise: If we believe coding is easy, we'll stop investing in the skills that make code reliable.
- Encourages over-reliance on AI: If we think code is the easy part, we'll let AI generate more code without sufficient review.
- Misleads junior developers: New programmers who hear this narrative may not invest in fundamental skills because they believe those skills don't matter.
- Creates false confidence: Decision-makers who believe coding is easy may reduce quality controls, leading to more bugs, security incidents, and technical debt.
What We Should Be Saying Instead
Instead of "code was never the hard part," we should say: "AI is changing which parts of coding are hard." Some things that used to be hard (writing boilerplate, scaffolding projects, generating tests) are getting easier. Other things (reviewing AI-generated code, understanding systems at scale, ensuring security) are getting harder.
The programmers who thrive in the AI era won't be the ones who dismiss coding as easy. They'll be the ones who understand that coding was always hard, that it's still hard, and that AI is a tool that changes the nature of the difficulty — not eliminates it.
Code was always the hard part. It still is. The only difference now is that we have a new tool that can help with some of it. But the difficulty hasn't gone away — it's just moved to different places.
What do you think? Is coding getting easier, or are we just seeing the difficulty shift? I'd love to hear your perspective in the comments.
Top comments (0)