maborak.com~/blog/how-ai-evolved-explained-to-kidssoftware & infrastructure engineering
Back to all articles

How AI grew up: from rules to learning machines

Seventy years of artificial intelligence for young readers, with a robot guide, a game where you teach a machine, and a quiz.Explained to kids

By the Maborak engineering team · · 10 min read · Leer en español

Bit:

Hi! I am Bit, a robot drawn for this page. I can’t think, but I know a story about machines that learned to do surprising things. Will you come along?

A long time ago, computers could only do exactly what people told them, one step at a time. Today some of them can chat, recognise animals in photos and help with homework. How did that happen? People spent more than seventy years working on it, and the story has a big surprise in the middle.

Checked 29 October 2026. Every date in this story comes from the original paper or announcement. The list is at the end, for grown-ups.

What is it?

Artificial intelligence, or AI, means making computers do things that need thinking when people do them: recognising a cat in a photo, understanding a question, or playing a game well.

To see why that is hard, you need to know what a computer program is. A program is a list of instructions, like a recipe. The computer follows the recipe exactly. It never guesses, never gets bored and never skips a step.

Bit:

Here is a recipe for me: “If it is sunny and warm, say let’s play outside. Otherwise, say let’s stay in.” I can follow that perfectly. But what if nobody gives me the recipe?

That is the big question in this story: can a computer do things nobody wrote a recipe for?

Can you think of something you know how to do, but could not explain as a recipe?Think first, then tap to see the answer

Recognising your friend’s face is a good example. You do it in a second, but try writing the steps: “If the nose is this long and the eyes are this far apart…” It is almost impossible. That is exactly the kind of problem the scientists in this story wanted computers to solve.

How does it work?

AI grew up in steps, like a person learning. Each step was built by people writing programs. Follow the timeline.

  1. 1950

    The big question

    A mathematician named Alan Turing wrote a paper that starts with a question: “Can machines think?” He suggested a game to test it. You chat with someone you cannot see. If you cannot tell whether it is a person or a machine, maybe the machine is thinking.

  2. 1956

    AI gets its name

    A group of scientists spent a summer at Dartmouth College, in the United States. Their plan, led by John McCarthy, used the words “artificial intelligence” for the first time. They believed every part of learning could be described so precisely that a machine could copy it.

  3. 1958

    A machine that learns

    Frank Rosenblatt built the perceptron. It did not follow a recipe for its answers. It learned from examples. Picture a seesaw: every time it guesses wrong, it tips a little toward the right answer. After enough examples, it stops making mistakes.

  4. 1959

    Practice makes better

    Arthur Samuel wrote a program that played checkers. It got better by playing over and over and remembering what worked. Samuel called this “machine learning”, and the name stuck.

  5. 1966

    A chatbot made of rules

    Joseph Weizenbaum wrote ELIZA, one of the first chatbots. It looked for words in what you typed and answered from a list of rules, like a robot reading cue cards. If you wrote “I am sad”, it could reply with a question about being sad.

Do you think ELIZA understood how you felt?Think first, then tap to see the answer

No. ELIZA matched words to rules, like finding a word in a dictionary and reading the line next to it. It had no idea what “sad” means. Even so, Weizenbaum wrote that some people were very hard to convince that ELIZA was not a person.

Bit:

So now there are two kinds of machines: the ones that follow rules, like ELIZA, and the ones that learn from examples, like the perceptron. Which kind won? Keep going.

  1. 1986

    Learning in teams

    One perceptron alone can only learn simple rules. A neural network connects many of them in layers, like a team passing notes forward. Three scientists showed how to train the whole team: when the final answer is wrong, the mistake is passed back through the layers, and every member adjusts a little.

  2. 2012

    Machines learn to see

    A neural network called AlexNet learned to recognise objects in more than a million photos, much better than the programs before it. It needed two things: lots of examples, and fast computer chips to learn from them.

  3. 2017

    Paying attention to words

    Researchers at Google described the Transformer. It lets a network look at all the words in a sentence at once and decide which words matter for each other. For example, in “The dog chased the ball because it was fast”, a network like this can learn that “it” means the dog.

  4. 2022

    Anyone can chat with AI

    On 30 November 2022, OpenAI released ChatGPT, a chatbot anyone could use. Part of its training came from people who chatted with it and ranked its answers from best to worst.

The learning machines won. Why do you think they needed so many examples?Think first, then tap to see the answer

Think about how you learned what a dog is. You saw many dogs: big, small, fluffy, spotty. A learning machine is the same, only slower. With a few photos it gets confused; with a million it starts to notice what all dogs have in common.

Why does it matter?

Here is the big surprise in the middle of the story. It is about who writes the rules.

  • In the old way, a person thinks of every rule and writes it down.
  • In the new way, a person writes a program that learns the rules from examples.

Learning machines can do things that are far too hard to write rules for, like telling a dog from a wolf or understanding a question asked in many different ways.

Bit:

But careful! A learning machine learns from its examples, mistakes included. If the examples are wrong, the machine learns the wrong thing.

Even the company that makes ChatGPT says it “sometimes writes plausible-sounding but incorrect or nonsensical answers”. In plain words: it can sound very sure and still be wrong. That is why people still check its work.

Try it

Now it is your turn to be the teacher. The machine below wants to know when to play outside, but it cannot see the secret rule. You pick the rule, then show it one day at a time. Watch its three dials turn every time it gets something wrong.

Teach the machine

Pick a rule, then press "Next day".

The machine's dials

sunny0.0
warm0.0
start0.0

Did the machine ever get worse before it got better?Think first, then tap to see the answer

With the first rule, yes. In round 3 it makes more mistakes than in round 2, because fixing one mistake can cause another. It keeps adjusting, and in round 6 it gets every day right. People learning a new skill often do the same.

No screen? Play it with a friend. Your friend thinks of a secret rule, like “I say yes only if it is sunny and warm.” They describe a day (“sunny, not warm”) and you guess yes or no. When you are wrong, change your guess a little next time. Count how many tries it takes until you never miss.

For grown-ups: the program behind the game, and what it printed when we tried it

The game uses the same learning steps as this small Python program. We ran it with Python 3.15.

days = [(1, 1), (1, 0), (0, 1), (0, 0)]                 # (sunny, warm): 1 = yes
answers = {(1, 1): 1, (1, 0): 0, (0, 1): 0, (0, 0): 0}  # play only if both

def rule(sunny, warm):                                   # the old way
    return 1 if sunny and warm else 0
print("Rule written by a person:", [rule(*d) for d in days])

w_sunny, w_warm, bias = 0.0, 0.0, 0.0                    # the learning way
for round_number in range(1, 20):
    mistakes = 0
    for sunny, warm in days:
        guess = 1 if w_sunny * sunny + w_warm * warm + bias > 0 else 0
        error = answers[(sunny, warm)] - guess
        if error:
            mistakes += 1
            w_sunny += 0.1 * error * sunny
            w_warm += 0.1 * error * warm
            bias += 0.1 * error
    print(f"Round {round_number}: {mistakes} mistakes")
    if mistakes == 0:
        break
print("Rule the computer learned:",
      [1 if w_sunny * s + w_warm * w + bias > 0 else 0 for s, w in days])

What it printed:

Rule written by a person: [1, 0, 0, 0]
Round 1: 3 mistakes
Round 2: 2 mistakes
Round 3: 3 mistakes
Round 4: 2 mistakes
Round 5: 2 mistakes
Round 6: 0 mistakes
Rule the computer learned: [1, 0, 0, 0]

Nobody told the program the rule, yet after five rounds with mistakes it gave the same answers as the rule a person wrote.

Quiz time

What is a computer program?
Which year did scientists first use the words "artificial intelligence"?
How does a perceptron learn?
Did ELIZA understand what people told it?
ChatGPT sounds very sure. Is it always right?

What to do

For a grown-up helping a young reader:

  • Play the game with each of the three secret rules and compare how many rounds the machine needs. Ask: “Why do you think this rule was easier?”
  • When using a chatbot together, check one of its answers in a book or a trusted website. It is a good habit, because chatbots can be wrong while sounding sure.
  • Talk about the difference between a recipe someone wrote and a skill someone practised. That is the difference between the first computers and today’s AI.
Bit:

Thanks for teaching my cousin the machine! Next time you hear “AI”, you will know its secret: someone built it to learn from examples.

Sources

For grown-ups:

Back to all articles

Technologies we work with

  • Argo CD
  • Kubernetes
  • Docker
  • Podman
  • Ansible
  • Jenkins
  • Chef
  • Proxmox VE
  • Google Cloud
  • Linux
  • Red Hat
  • CentOS
  • NGINX
  • Apache
  • Traefik
  • Prometheus
  • Grafana
  • PostgreSQL
  • MySQL
  • MariaDB
  • Redis
  • etcd
  • Qdrant
  • Elasticsearch
  • Logstash
  • Kibana
  • PagerDuty
  • Go
  • Python
  • FastAPI
  • PHP
  • TypeScript
  • React