What Is Artificial Intelligence?

Today the same term is used for a spell checker, a recommendation engine, a medical diagnosis system, and a text generator. These four programs have almost no technique in common. When an expression covers objects this different, it ends up meaning nothing, and that is exactly the problem facing anyone who tries to evaluate an announcement, a product, or a job posting containing the letters “AI.”

This confusion has a concrete cost. Without precise vocabulary, you cannot tell a system that applies rules written by a human from one that inferred its rules from thousands of examples. Yet the two do not fail in the same way, are not fixed in the same way, and do not carry the same accountability. You don’t debug a statistic the way you debug an if condition.

This lesson establishes that vocabulary. We will look at where the term comes from, why two research traditions opposed each other for thirty years before one of them took the lead, how the three expressions people confuse most often fit together (artificial intelligence, machine learning, deep learning), and above all where the real limits of these systems lie today.

That last point is the most useful. Knowing what a technique cannot do is what separates a practitioner from a spectator.

A Definition That Holds Up

There is no single, consensus definition of artificial intelligence. The one that holds up best in practice is functional: we speak of AI when a program performs a task for which no one has been able to write the rule to apply, or for which that rule would be too long to enumerate.

The term was born in 1956 at a summer research workshop held at Dartmouth College. John McCarthy coined the expression artificial intelligence in the funding proposal written the previous year. Six years earlier, in 1950, Alan Turing had published the article “Computing Machinery and Intelligence” in the journal Mind, which sidesteps the question “can a machine think?” by replacing it with an observable protocol: can a human interlocutor tell a machine from a person in a written exchange?

This shift is clever, but it has a side effect: it equates intelligence with producing plausible answers. Yet producing plausible output is perfectly achievable without understanding anything.

# A 1966 "conversational agent" fits in a few lines.
REGLES = {
    "bonjour": "Bonjour. De quoi voulez-vous parler ?",
    "je suis triste": "Depuis quand vous sentez-vous triste ?",
}

def repondre(phrase):
    return REGLES.get(phrase.lower().strip(), "Pouvez-vous reformuler ?")

print(repondre("Bonjour"))          # Bonjour. De quoi voulez-vous parler ?
print(repondre("je suis épuisé"))   # Pouvez-vous reformuler ?

The first exchange looks credible. The second reveals the mechanism: “je suis épuisé” (“I am exhausted”) is very close to “je suis triste” (“I am sad”), but the dictionary does not contain that exact key, so the program falls back on its catch-all phrase. It has no notion of closeness in meaning. This is the principle behind ELIZA, the program written by Joseph Weizenbaum at MIT in 1966, whose users spontaneously attributed to it an understanding it did not have.

This functional definition has an amusing consequence, known as the AI effect: as soon as a problem is solved reliably, we stop calling it artificial intelligence. Character recognition, route calculation, bank fraud detection, and chess were once AI topics. Today they are just software. The expression still designates the moving frontier of what we don’t yet know how to do well.

Two Traditions: Writing the Rules or Learning from Examples

For the first thirty years, the dominant approach was to write knowledge down explicitly. This is called symbolic AI: the knowledge of a domain is encoded as facts and logical rules, and an inference engine chains them together.

This approach produced real results. The expert systems of the 1970s and 1980s, such as MYCIN at Stanford for diagnosing bacterial infections, reached a quality comparable to that of human specialists within their narrow domain. In 1997, the Deep Blue program beat world champion Garry Kasparov at chess, essentially through game-tree search and a hand-written evaluation function: no learning at all.

Two obstacles blocked this path. First, combinatorial explosion: the number of rules needed grows much faster than the coverage achieved. Second, the knowledge acquisition bottleneck: you need a human expert who is available and able to make explicit what they know. For recognizing a cat in a photo, no one has ever managed to write those rules, because no one knows how they do it themselves.

The other tradition turns the problem around: instead of writing the rule, you provide examples and let an algorithm fit the rule.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB

messages = [
    "gagnez 1000 euros maintenant",
    "cliquez ici pour recevoir votre cadeau",
    "reunion projet demain 14h",
    "compte rendu de la reunion en piece jointe",
]
etiquettes = [1, 1, 0, 0]          # 1 = spam, 0 = legitimate

# Each message becomes a vector of word counts.
vectoriseur = CountVectorizer()
X = vectoriseur.fit_transform(messages)

modele = MultinomialNB().fit(X, etiquettes)

# A sentence never seen before, made of words seen in the spam messages.
nouveau = vectoriseur.transform(["gagnez votre cadeau maintenant"])
print(modele.predict(nouveau))     # [1]
print(len(vectoriseur.vocabulary_))  # 21

No one wrote the rule “if the message contains gagnez (“win”) and cadeau (“gift”), then it’s spam.” It was deduced from the counts. The number to remember is the last one: four messages already produce 21 words of vocabulary. On a realistic corpus of tens of thousands of messages, the vocabulary reaches tens of thousands of entries, and the model weights each one. Writing those weights by hand isn’t just difficult: it’s impossible.

It would be dishonest to conclude that the symbolic approach has been refuted. It is very much alive where guarantees matter more than flexibility: constraint solvers, planning, formal software verification, business rule engines. A production system often combines both, with a learned model for perception and explicit rules for decisions that must be justified.

AI, Machine Learning, Deep Learning

These three expressions are not synonyms. They are nested.

┌──────────────────────────────────────────────────────┐
│ ARTIFICIAL INTELLIGENCE                              │
│ Getting a machine to perform a task whose rule is    │
│ not written down. Includes logic, tree search,       │
│ expert systems.                                      │
│                                                      │
│   ┌──────────────────────────────────────────────┐   │
│   │ MACHINE LEARNING                             │   │
│   │ The rule is fitted from data.                │   │
│   │ Regression, trees, forests, SVM, Bayesian.   │   │
│   │                                              │   │
│   │   ┌──────────────────────────────────────┐   │   │
│   │   │ DEEP LEARNING                        │   │   │
│   │   │ Neural networks with many layers.    │   │   │
│   │   │ Images, text, audio.                 │   │   │
│   │   └──────────────────────────────────────┘   │   │
│   └──────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────┘

You can check how to read the diagram against concrete cases:

The last row deserves attention: a program can be complex, automated, and useful without being AI. If the rule is written down and known, it’s software.

The shift to deep learning has a landmark date: in 2012, a convolutional network called AlexNet won the ImageNet image recognition competition with a top-5 error rate of about 15%, compared to about 26% for the best competing method. A gap of that size, in an established competition, redirected the field within months. The ideas themselves were not new: Frank Rosenblatt’s perceptron dates from 1957, and backpropagation was popularized in 1986. What changed was the amount of labeled data available and the computing power of graphics cards.

Two Winters, and What They Teach

The history of AI is not one of continuous progress. It alternates between phases of enthusiasm, abundant funding, and public promises, and phases of disillusionment called AI winters, in which budgets and interest collapse.

Two lessons emerge from this cycle, and they are directly useful today.

The first is that the winters followed dated, unkept promises, not technical failures. Research continued through both winters; what collapsed was the credibility of announcements that were too specific about timelines. It’s a lesson in intellectual hygiene: caution should apply to dates and deadlines, rarely to direction.

The second is that difficulty is not distributed the way intuition suggests. The tasks humans find difficult and prestigious (playing chess, integrating a function, remembering a database) turned out to be the easiest to automate. The tasks any child masters (recognizing a partially hidden object, grasping a glass, understanding an implicit instruction) resisted for decades. This reversal, often called Moravec’s paradox, predicts the feasibility of a project better than any intuition about the apparent “complexity” of a task.

What AI Cannot Do

A learned model has no knowledge of the world: it has a statistical regularity extracted from a sample. Anything outside that sample is outside its domain of validity, and nothing in the model signals when that boundary is crossed.

import numpy as np
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression

iris = load_iris()   # 150 flowers, 4 measurements, 3 species
modele = LogisticRegression(max_iter=200).fit(iris.data, iris.target)

# Dimensions that match no iris: more like a sunflower.
absurde = np.array([[40.0, 25.0, 60.0, 15.0]])
print(modele.predict(absurde))                 # [2]
print(modele.predict_proba(absurde).round(3))  # [[0. 0. 1.]]

The model answers “virginica,” with a probability rounded to 1. It has no mechanism for answering “this object looks like nothing I’ve seen.” It learned to split the measurement space into three regions, and every point necessarily falls into one region. A high probability measures position within that partition, not the reliability of the answer.

Three other limits, structural rather than anecdotal:

• No causality. A model captures associations. If it learned that the presence of umbrellas predicts rain, it will predict correctly without ever being able to say that removing the umbrellas won’t change the weather. Distinguishing correlation from causation requires either an experimental intervention or assumptions added from outside.
• No goals of its own. A model optimizes the quantity it was given to optimize. A recommendation system trained to maximize time spent will maximize time spent, including by means no one anticipated.
• No verification of what is produced. A language model is trained to produce a plausible sequence of words, not a true one. This is the mechanism behind what is called hallucination, which we will take apart piece by piece in the lesson on language processing.

Finally, the most frequent gap in practice is not technical but one of formulation:

Every row of this table is a real project that failed. None of them is an algorithm flaw: they are target errors, and they are fixed upstream of the code.

Key Takeaways

• The term AI applies when a program performs a task whose rule was never written down explicitly. The boundary keeps moving: whatever works reliably eventually gets called “software.”
• Two traditions coexist: writing the rules by hand (symbolic AI, expert systems, solvers) and having them inferred from data (machine learning). The latter has dominated since the 1990s, while the former remains indispensable when you need to guarantee and justify results.
• The three terms nest inside one another: deep learning is a subset of machine learning, which is itself a subset of AI. Not every AI system learns, and not every automated piece of software is AI.
• A trained model only knows its sample. It answers with the same confidence inside its domain of validity and outside it, and a high probability is not a guarantee of correctness.
• The most common failure comes from the choice of the quantity being optimized, not from the algorithm: the machine hits exactly the objective you set for it, even when that was not the one you wanted.