Browsing old files last week, I found a quote from 1983 that stopped me for a moment:

“Real Programmers do Artificial Intelligence programs in FORTRAN.”

Forty-three years later, that joke hits differently.

At the time, it was satire. AI meant symbolic systems and Lisp machines. FORTRAN meant numerical computing. Claiming that “real programmers” would write AI in FORTRAN was deliberately absurd — a jab at macho developer culture and language tribalism.

But reading it today, in the age of GPT, Claude, and Gemini, it feels less like a joke about AI and more like a timeless observation about us.

The war never ends — it just rebrands

The original satire nailed something enduring:
developers will always form factions around tools.

Back then it was:

  • Lisp vs. Prolog
  • C vs. Pascal
  • “Structured programming” vs. “real programming”

Today it’s:

  • GPT vs. Claude vs. Gemini
  • Copilot vs. Claude Code
  • Rust vs. Go
  • VS Code vs. JetBrains

The pattern is unchanged:

  1. Pick a tool.
  2. Attach identity.
  3. Defend it with the passion of sports fandom.
  4. Declare everyone else unserious.

It’s comforting. It creates a clean story:
If we choose the right tool, we win.

But that’s rarely where the real advantage lies.

Tool choice is rarely the differentiator

Yes, tools matter. Bad tools slow you down. Good tools accelerate you.

But most performance gaps between teams are not explained by language or model choice. They’re explained by fundamentals:

  • Do you understand the problem?
  • Do you ship in small increments?
  • Do you measure outcomes?
  • Do you integrate feedback?
  • Do you use tools deliberately instead of ideologically?

Last month we evaluated different AI coding assistants for a team. The debate started as, “Which one is smarter?” Within an hour it became clear that the real question wasn’t intelligence — it was integration. Which one fits our compliance constraints? Which one works with our on-prem repositories? Which one aligns with our security model?

The model comparison was interesting.
The workflow implications were decisive.

That’s usually how these debates end — once you stop performing identity and start optimizing for outcomes.

The FORTRAN irony deserves more credit

Here’s the part that makes the original quote even better with hindsight.

The joke is that the author was accidentally right.

Modern AI does run on FORTRAN’s spiritual descendants. Those BLAS libraries and GPU kernels performing matrix multiplications are much closer to FORTRAN’s numerical computing DNA than to Lisp’s symbolic reasoning roots.

The AI revolution wasn’t won by symbolic purity.
It was won by scalable numerical computation.

The “real programmer” flex completely missed the direction history was about to take.

GPT vs. Claude vs. Gemini: the new FORTRAN vs. Lisp

Today’s debates follow the same pattern:

  • “Claude reasons better.”
  • “GPT writes cleaner code.”
  • “Gemini integrates better with our stack.”

Some of that is true in specific contexts. But the winning move isn’t picking a champion. It’s building a system of work.

High-performing teams don’t just “use AI.” They:

  • Define where it reduces cycle time
  • Establish review and validation loops
  • Understand its failure modes
  • Measure impact

Model choice matters.
Workflow design matters more.

Assembly taught me something about this

Here’s what changed my perspective on abstraction layers.

In my early twenties I decided life is too short to program in assembly and switched to Java, C++ and C#. That wasn’t lowering standards. It was choosing leverage. I could build more meaningful systems by operating at a higher level of abstraction.

Assembly still exists — in kernels, embedded systems, performance hotspots. But almost nobody builds complete products in it anymore. Not because we forgot how. Because we learned that leverage scales better than heroics.

Today it feels similar.

Life is too short not to use AI when building software.

Not as a crutch. Not as a substitute for thinking.
But as the next layer of abstraction.

We moved from assembly to high-level languages to gain leverage.
Using AI well is simply the next step in that progression.

So yes, “Real Programmers do AI in FORTRAN.”

And in Lisp.
And in Python.
And with GPT, Claude, Gemini — and whatever comes next.

Because real programmers don’t defend tools as identity.

They use leverage.