For most of the computer age, programming meant telling a machine exactly what to do. I know because I started learning programming about sixty years ago. I studied computer science at Sir George Williams University, which later became part of Concordia University. We worked with languages such as FORTRAN, COBOL and later Pascal. Programs weren’t stored conveniently on a laptop or floating somewhere in the cloud.

 

We punched them onto cards.

 

A substantial program could become a physical stack of cards you carried around. If you got the cards out of sequence, you had a problem. Lose them, and you had a much bigger one. I discovered that rather dramatically when somebody stole one of my programs.

 

The stack was nearly a foot high.

 

When I reported it, my teacher asked me about some distinctive elements in the program. From those details, he identified the culprit, and I eventually got my stack of cards back. It was an early lesson in something we don’t often associate with computer programs.

 

Code carries traces of the person who created it.

 

It was also an early lesson in the importance of attribution. Ideas have origins. Work has authors. A citation does more than acknowledge where something came from — it allows others to follow the trail, examine the source and build upon it.

That mattered when humans were writing the programs. It may matter even more when machines help write them. Today, the machine itself is beginning to create code. And that changes rather more than programming.

Programming Was About Instructions

Traditional programming was fundamentally explicit. You analysed a problem, worked out the logic, drew flowcharts and converted that logic into instructions the computer could execute.

 

  • If this happens, do that.
  • If something else happens, do something else.
  • Otherwise, do this.
Computers were extraordinarily fast and wonderfully obedient. But they weren’t terribly forgiving.

If you hadn’t anticipated something, the computer wasn’t likely to stop and say:

Surely you meant this?

It did what you told it to do.

That made the real challenge of programming not simply writing code, but understanding the problem well enough to anticipate what might happen. And real life has an inconvenient habit of becoming complicated.

When a Simple Booking Isn’t Simple

I encountered that years later while developing computer systems for tourism in Barbados. Booking a hotel room sounds straightforward. A traveller wants a room. The hotel has a room. Make the reservation.

Then you start programming it.

  • What season is it?
  • How many people are staying?
  • How many adults?
  • Are there children?
  • How old are they?
  • Which room category?
  • Which meal plan?
  • What rate applies?
  • What amenities and features does the traveller want?

One hotel might allow the first child to stay free and charge for the second. Another might structure the rule differently. Different hotels defined children’s ages differently. Rates changed by season, occupancy and room type. Before long, a seemingly simple transaction had become an extraordinary collection of rules, conditions and exceptions.

The programmer had to anticipate them.

  • IF this, THEN that.
  • EXCEPT when this.
  • UNLESS that.

The computer wasn’t finding the solution.

We were!
The computer was executing the solution we had painstakingly described. That work eventually contributed to a booking system for independent Barbados hotels at a time when sophisticated reservation technology was largely the preserve of bigger hotel companies.

But another problem interested me even more.

Which Hotel Is Right for You?

Availability is one thing.  Suitability is another. A conventional booking engine can answer: Which hotels have rooms available? But travellers don’t really want an available hotel.

Travellers want a hotel they’ll enjoy.

A sophisticated, formal hotel might be perfect for one traveller and completely wrong for another. Someone looking for adventure, activity and nightlife probably doesn’t want the same experience as someone seeking tranquillity, elegance and seclusion.

How could we teach a computer something as subjective as that? I became interested in the ideas behind early matchmaking systems. If a computer could match people according to characteristics, we could apply a similar idea to travel. We began experimenting with characteristics that could describe both people and hotels.

We eventually refined the original collection to about forty human characteristics. Later, we expanded the thinking using ideas about personality and fascination—trying to identify words and characteristics that captured what attracted people and what distinguished particular hotels.

The resulting RealHolidays/Persona system attempted to build an impression of the traveller from preferences and behaviour and compare that with a character profile of the hotel.

Suddenly the question wasn’t merely:

  – Can I book this hotel?

It was:

  – Does this hotel fit me?

Trying to Program Judgement

This was still programming. We had to design the characteristics, define relationships, construct the rules and decide how matches should work.

But something had changed.

We weren’t simply trying to automate a transaction anymore. We were trying to encode judgement. And we recognised its limitations.

Someone with knowledge of the hotels could check the automated assessment—applying personal experience and common sense to decide whether the computer’s recommendation actually made sense.
Looking back, that distinction seems remarkably relevant today.

 

  • The program could calculate.
  • The system could match.
  • But a human still judged the result.

Then Programming Changed

Traditional software still surrounds us, and programmers still write enormous amounts of conventional code. But artificial intelligence introduced a fundamentally different idea. Instead of specifying every relationship ourselves, we can build systems that learn relationships from data. We still build the architecture. We still determine objectives. We still provide information, constraints and feedback. But we don’t individually program everything the system eventually learns.

 

As we explored earlier in How Does AI Learn?, the system predicts, compares, adjusts and repeats. In doing so, neural networks develop internal representations and relationships that no programmer explicitly entered one at a time.

 

That changes the old relationship.

 

For much of computing history: Human understands problem → Human writes instructions → Machine executes them.

With machine learning: Humans build a learning system → Machine learns patterns → Machine applies what it has learned.

And now another change is underway.

The Machine Writes the Program

Today’s AI systems can generate working computer code from ordinary language. Describe what you want and an AI can propose the program.

 

  • It can explain existing code.
  • Find bugs.
  • Suggest improvements.
  • Translate between programming languages.
  • Write tests.
  • Rewrite inefficient sections.

And increasingly, it can help develop substantial software systems.

 

That doesn’t mean programmers have disappeared. But something profound has changed. Programmers once had to translate human intention into the machine’s precise language. Increasingly, the machine can participate in that translation itself. We can say what we want to accomplish rather than specifying every instruction required to do it.

 

That raises an obvious question.

What Happens to the Programmer?

We’ve heard versions of this question throughout computing history. Higher-level programming languages reduced the need to work directly with machine instructions.

  • Compilers automated translation.
  • Databases abstracted data management.
  • Spreadsheets allowed millions of people to perform computations without thinking of themselves as programmers.
  • Each layer removed some technical work.
But it also allowed us to tackle more complicated problems.

 

AI may be another—and much larger—step in that progression.
If machines become extraordinarily good at producing code, the scarce skill may no longer be the ability to type instructions in a particular programming language.

 

It may already be:

  • Understanding the problem.
  • Knowing what should be built.
  • Recognising what information matters.
  • Seeing the exceptions.
  • Testing whether the result actually works.
And perhaps most importantly, deciding whether what we’ve built makes sense.
That takes us straight back to common sense.

AI Can Code, but Does It Understand the Problem?

A machine can produce flawless code for the wrong objective. It can efficiently implement a bad assumption. It can automate a process that shouldn’t have existed in the first place.

That’s why programming has never really been only about programming languages.
The hardest part was often understanding the system surrounding the code. My old hotel booking problem wasn’t difficult because the computer couldn’t perform the calculations. The difficulty was understanding all the messy exceptions of real hotels and real travellers. Persona went further because the question itself became less precise.

What does this person actually want?

Because every click, every choice, every page opened, every image or video watched provides a signal. Today’s AI can help enormously with both problems. Taken together — and viewed across every step of the journey — those signals can reveal interests, preferences and patterns of behaviour.

From Punch Cards to Programming Intelligence

I sometimes think about that stolen stack of punch cards. Nearly a foot of cardboard represented a program I had painstakingly created. A human had to put every instruction there. Sixty years later, I can describe a problem to an artificial intelligence in ordinary language and watch it generate code in seconds.

That is an astonishing transition. But the most interesting change isn’t that AI can write code faster than we can. It’s that the relationship between human and machine is changing again. We once told computers how to do things.

Increasingly, we can tell them what we’re trying to achieve and allow them to help determine how.

That doesn’t eliminate human intelligence.

It moves it.

From Programming Machines to Creating Intelligence

But that raises another possibility.

There are really three stages:

Humans programming machines → machines programming themselves → machines creating intelligence.

The last step may already be beginning.

Programming is no longer simply about telling a machine what to do.
It is becoming a way of building intelligence itself. 

But recent reports of rogue AI behaviour raise a more unsettling possibility.

The future may not simply be humans and machines programming together. What happens when machines can modify, replicate or program themselves without human intervention?

That is a subject for another episode, coming soon.

Carousel

Programming Intelligence — At a Glance

From writing precise instructions to building machines that can write code themselves, programming is changing.

This short visual summary explores what that shift may mean for programmers — and why human judgement may matter more, not less.

Summary video

Cite this article

Clayton, Ian R. “Programming Intelligence: When Machines Write the Code.” Rogues in Paradise, 3 September 2026. https://roguesinparadise.com/programmingintelligence

SERIES: INTELLIGENCE

This series explores the nature of human, artificial and superhuman intelligence—where they differ, where they overlap, and where they may be heading. It examines intelligence beyond reasoning and knowledge, exploring consciousness, emotional intelligence, wisdom, character and the emerging capabilities of AI, as well as the opportunities, uncertainties and risks they may bring.

Episode 1 – What is Intelligence – Human Intelligence in the Age of AI

The many faces of intelligence:  why intelligence, common sense and wisdom are not the same thing

Episode 2 – How Does AI Learn? A Simple Idea, Complex Intelligence

These aren’t conventional computer programs. What exactly are we building?

Episode 3 – Can AI Develop Common Sense? Why It Matters

Can prediction, perception and internal representations produce something resembling common sense?

Episode 4 — Programming Intelligence – When Machines Write the Code

What happens when machines can write code — and begin helping to build intelligence itself?

Episode 5 — When AI Goes Rogue –What Happens When AI Stops Following Instructions?

What happens when intelligent agents gain autonomy, learn unexpected behaviours and begin acting beyond what their creators intended?

Episode 6 — When Intelligence Solves the Impossible – Is It Rogue?

What happens when AI begins solving problems humans cannot? From mathematics and medicine to science and engineering, artificial intelligence may allow us to tackle questions that have resisted human intelligence for decades — or centuries.

Episode 7 — Who Owns AI Intelligence? – Should We Share?

When AI learns from human writing, art, ideas and experience, what happens to copyright, attribution and intellectual property — and what does intelligence owe the people it learned from?

Episode 8 — Does AI Have Character? If So What Is It?

Can learned behaviour, context and generalisation create something resembling character? And what happens when those traits carry into new situations?

Episode 9 — Can AI KNOW Anything?- Does it Know Everything?

What is the difference between storing information, predicting correctly, understanding, believing — and actually knowing?

 

NEXT SERIES: THE MIND WORKERS

After exploring how artificial intelligence is changing our world in Living with AI, The Mind Workers asks a different question:

Who must we become?

Thinking Smarter. Creating Better. Staying Human.

The Mind Workers explores how writers, researchers, educators, creators, entrepreneurs, and independent thinkers can thrive alongside intelligent systems—preserving the uniquely human qualities that artificial intelligence cannot replace.

The Mind Workers – Prelude: https://roguesinparadise.com/mindworkers/

FUTURE SERIES – BUILDING WITH AI

Building with AI explores how individuals, creators, entrepreneurs, and businesses can design, evaluate, and work intelligently with AI agents. The series focuses on practical applications, real-world examples, and emerging opportunities while emphasising the importance of human creativity, judgment, ethics, and authenticity.

Building With AI then puts these ideas into practice through real-world experiments, workflows, and practical applications.

Prelude:  https://roguesinparadise.com/building-with-ai/

INSPIRED BY THE BOOK
ROGUES IN PARADISE

How Britain’s First Slave Colony Became a Global Force.
A Creative Chronicle of Unlikely Heroes, Rogues, and Legends
in Empire’s Shadow

Explore the ideas behind the book  —or
Go straight to the story.

rogues in paradise

Unlikely voices, rogues and legends, rising from Britain’s blueprint for slavery to a republic beyond the Empire’s shadow