This post is a response to the article “Young Coders Are Using AI for Everything, Giving ‘Blank Stares’ When Asked How Programs Actually Work”, originally published by Futurism and based on a blog post by developer Namanyay Goel.
Young Coders Are Using AI for Everything, Giving “Blank Stares” When Asked How Programs Actually Work
Young programmers “can’t actually program” because they’re too reliant on AI models, writes developer Namanyay Goel.
FuturismFrank Landymore

In that piece, Goel argues that today’s junior developers are too reliant on AI tools like ChatGPT and GitHub Copilot — producing functional code without truly understanding it. According to him, we’re trading foundational learning for convenience, and it's a shortcut we'll regret later.

But is that really the whole story?

This post dives deeper into that claim — not to dismiss the concern outright, but to explore a more nuanced view of how developers are learning today. Spoiler alert: coding isn't dying. It's evolving — and maybe getting better.

Let’s dig in.

The Romantic Myth of the Struggle - StackOverflow as Rite of Passage

Let’s pour one out for the golden era of coding: a time when we wore our StackOverflow badges like tribal tattoos and memorized error messages like scripture. The article by Futurism, based on Namanyay Goel's blog post, clings lovingly to this vision — an age when junior devs were forged in the fires of confusion and poor documentation.

Goel’s argument? AI makes it too easy. Junior devs are shipping code but can’t explain it. They give “blank stares” when asked about edge cases. They don't suffer anymore. And that, apparently, is the issue.

But is struggle really the only path to mastery? Or are we just nostalgic for a time when the only debugger we had was sheer willpower?

AI as the New Mentor - Real-Time, Context-Aware Tutoring

Enter AI — not as the villain, but as the tutor who never sleeps, judges, or gatekeeps. Tools like Cursor, Windsurf, GitHub Copilot, even ChatGPT, and Claude are essentially on-demand code mentors. They’re interactive, responsive, and faster than waiting for a reply on a forum.

What AI-assisted learning actually looks like:

  • You're watching code generate in front of your eyes.
  • You can ask why that particular pattern was chosen.
  • You can modify and break it, then see what happens.
  • You can debug together — in real time.

This isn’t passive spoon-feeding. It’s apprenticeship on steroids.

Learning While Building - Code Isn’t a Temple, It’s a Workshop

One of the most ignored truths in the “AI-is-ruining-devs” narrative is this: developers are still learning — but they're doing it by building actual things.

Want a blog deployed with authentication and Stripe integration? You can scaffold it with AI in minutes — and then you start learning:

  • What happens when your Stripe key is misconfigured?
  • Why is CORS breaking in production?
  • What does that mysterious CI pipeline error mean?

That’s real-world, full-stack, fire-drill-style education. It's not theory — it's practice.

The Copy-Paste Conundrum - Who Really Started It?

Goel criticizes AI-powered devs for “just going to chat.com and copying errors.” But... wasn't that already happening with StackOverflow?

Raise your hand if you’ve:

  • Copied an answer from StackOverflow.
  • Pasted it.
  • Said a silent prayer that it works.

Let’s not pretend AI invented this behaviour. What’s different now is that:

  • You can ask the AI to explain the code.
  • You can tweak it and regenerate.
  • You don’t need to wade through 18 different “deprecated” replies.

It’s not about not copying — it’s about copying with context and accountability.

Cognitive Offloading or Just... Progress?

Yes, the Microsoft/Carnegie Mellon study warns of “cognitive offloading” — trusting AI too much and thinking too little. But isn’t that the history of technology?

We don’t:

  • Memorize phone numbers anymore.
  • Do long division by hand.
  • Use map coordinates to drive cross-country.

And yet, civilization continues.

Offloading mental tasks isn’t always bad. It frees up brain space for higher-order thinking — like architecture, optimization, and user experience. You know, the stuff that actually matters in real-world software.

Reframing the Narrative - AI as a Great Equalizer, Not a Crutch

The hand-wringing around AI often assumes we’re breeding a generation of lazy coders. But what if we’re actually:

  • Making coding accessible to people from non-traditional backgrounds?
  • Enabling faster experimentation and innovation?
  • Allowing devs to spend more time solving real-world problems instead of wrangling syntax?

Instead of gatekeeping based on how many nights you've cried over a Docker error, let’s celebrate the fact that more people can now build more things, faster.

AI didn’t kill the dev star. It just gave it a better keyboard.

Beating the Machine - Why a Good Developer Must Be Better Than AI

Here’s the blunt truth that should be getting more airtime: to be a great developer today, you have to be better than AI — not just use it.

We’re no longer in an era where knowing a few JavaScript loops and how to center a div puts you ahead. If AI can generate basic boilerplate, scaffold a React app, or even spit out a decent sorting algorithm in five seconds, then what’s your edge as a human developer?

The New Bar - Thinking Beyond the Prompt

What separates a developer from a code typist in the AI age isn’t typing — it’s thinking:

  • Critical thinking to evaluate if the AI’s solution actually fits the problem.
  • System design knowledge to architect scalable and maintainable solutions — not just functional ones.
  • User empathy to build software that isn’t just correct, but delightful.
  • Security, performance, ethics, context — all the nuance AI doesn’t inherently understand.

AI can assist with syntax and structure. You bring the strategy, insight, and judgment.

Debugging, Diagnosing, and Discerning

AI can hallucinate, make silent logic errors, or recommend deprecated methods. A good dev must:

  • Catch those errors.
  • Know what should have been generated.
  • Understand when the AI is confidently wrong (which is often the most dangerous kind of wrong).

Creativity Is Still Human Terrain

Building something original — be it a game mechanic, a new interaction model, or a clever algorithmic twist — is still a deeply creative process. AI can remix existing ideas, but innovation still requires a spark it hasn’t learned to fake… yet.

📈 So What’s the Bar Now?

It’s not about beating AI at code generation. That ship has sailed. It’s about:

  • Being the editor, architect, and overseer of AI-generated work.
  • Understanding what great looks like — not just what “runs.”
  • Constantly sharpening your edge — because AI is evolving too.

Code Is Still Being Written, Just Faster, Smarter, and Maybe Better

The “old-school suffering = good developer” myth needs to go. Pain might have been the default learning tool back then, but now we have better ones.

Yes, AI changes how we learn — but it doesn’t eliminate learning. It accelerates it, opens doors, and gives junior devs the ability to do, not just read.

So instead of hand-wringing about blank stares, maybe we should ask ourselves:

Are we judging the learning curve by the wrong curve?

TL;DR: AI can now do what junior devs used to be paid for. So the path to becoming a great dev? Learn to leverage AI — then outperform it where it matters most: design, judgment, creativity, and the stuff it still doesn’t quite get.

Don't try to out-type the machine. Out-think it.

Let the new devs cook. Just... maybe have a few unit tests handy.