“What has been is what will be, and what has been done is what will be done; there is nothing new under the sun.” — Ecclesiastes 1:9

Every generation believes its revolution is the most significant turning point in human history. The printing press, the industrial age, the Internet, and now the AI revolution all hailed as seismic shifts that will rewrite the rules forever. And yet, with every wave of change, there’s an older voice that reminds us: we’ve been here before. The tools change, but the essence of human challenges and achievements remains surprisingly constant.

Today, the rise of Large Language Models (LLMs) like OpenAI’s GPT models, Meta’s Llama, Google’s Gemini, and Anthropic’s Claude has sparked a familiar wave of techno-evangelism. Some say that within a few years, developers will be obsolete, replaced by AI that can write software by itself. The “no-code/low-code” revolution is back again but this time with fancier autocomplete.

But there’s a fundamental misunderstanding at play: just because AI can write code doesn’t mean it can build software.

Writing Code ≠ Engineering Software

Writing code is easy. Writing good code is hard. But writing great software, the kind that scales, survives, and serves people is a completely different discipline.

Let’s put it in simpler terms:

• Writing code is like typing words.
• Software engineering is like writing a novel that others can read, maintain, extend, and trust for years to come.

Code is just the visible layer of a much deeper craft. The real work of software engineering lies in:

• Understanding what users need (not just what they say they want),
• Designing robust systems that work under pressure and failure,
• Making decisions about tradeoffs speed vs. security, cost vs. performance, features vs. simplicity.

Here’s a breakdown of the difference:

The Gaps LLMs Can’t Fill (Yet)

1. Problem Solving vs. Typing

LLMs are amazing at translating a well-defined prompt into code. But in the real world, problems are not well-defined. They are ambiguous, contradictory, or invisible. Engineers must discover and frame the problem before solving it.

2. Hacks vs. Systems

Code that works today may become tomorrow’s nightmare. Engineers think in terms of architecture, maintenance, and scale, not just whether it runs on their machine.

3. Solo Projects vs. Teamwork

Software today is built in teams. That requires communication, reviews, CI/CD pipelines, testing, and iteration. AI can help with parts of this, but it doesn’t know your team, your constraints, or your users.

4. Working Code vs. Graceful Failure

Anyone can write a function that works for ideal input. Engineers design systems that handle failure, monitor themselves, alert the right people, and fail gracefully.

5. Autocomplete vs. Craft

LLMs help autocomplete code. Engineers decide what to build, why it matters, and when to ship. That’s craft, not syntax.

Asimov’s Warning: The Creativity Filter

To illustrate this further, let’s turn to Isaac Asimov’s short story “Profession”, found in his collection “Nine Tomorrows”.

In a dystopian future, people are “educated” instantly at age eighteen through brain implants called Tapes. Careers are assigned based on a brain scan, and society celebrates conformity and efficiency above all. Only those with the best scores get exported to prestigious Outworlds; staying on Earth is a kind of shame.

George Platen, the protagonist, dreams of becoming a programmer, only to be told he’s mentally unfit for education. He’s drugged and placed in a home for the feeble-minded. But over time, it’s revealed that this “House” is actually an elite Institute of Higher Studies, a haven for those who can think originally. George wasn’t a failure; he was part of a tiny group being tested for creativity, self-direction, and insight.

The people who program the Tapes, the ones who invent the systems aren’t the ones who followed the rules. They’re the ones who broke them with purpose.

What This Means for the AI Generation

The story is a metaphor for our current moment. AI can follow patterns. It can mirror existing code and even optimize it. But the people who build the future, the people who invent new tools, systems, and protocols are still the ones who ask hard questions, take risks, and imagine new possibilities.

AI is an incredible tool, and we should embrace it. But we shouldn’t confuse speed for strategy, or autocomplete for architecture.

Writing code will get easier. But building great software that matters will always require human insight, creativity, and collaboration.

Final Thought

The next time someone says, “AI will replace developers”, remind them of Ecclesiastes: “There is nothing new under the sun.”

We’ve heard it before. And each time, it ends the same way not with the death of a profession, but with its evolution. The tools change. The craft endures.

‍