What AI Is (and Isn't)

Why this matters

"AI" is printed on everything from phone cameras to spreadsheets, and the word covers very different technologies. Knowing what it actually refers to helps you judge claims, pick the right tool, and avoid trusting a system for things it was never built to do.

A working definition

Artificial intelligence (AI) is the broad field of building computer systems that perform tasks we would normally say require human intelligence: recognising speech, translating languages, spotting patterns, making predictions, or writing text.

That definition is about behaviour, not about how the system works inside. A chess program from the 1990s that follows hand-written rules counts as AI. So does a modern chatbot. They work in completely different ways.

Four terms that nest inside each other

The easiest way to keep the jargon straight is to picture a set of nesting boxes, each one inside the last.

So every generative AI system is a deep learning system, every deep learning system is machine learning, and all of it is AI. The reverse is not true: plenty of AI involves no learning at all.

Narrow AI vs general AI

Narrow AI is built for a specific task or family of tasks. A system that reads X-rays, a translation app, and a recommendation engine are all narrow. Every AI system in use today is, by most researchers' definitions, narrow, even when the range of tasks is surprisingly wide.

Artificial general intelligence (AGI) is a hypothetical system that could learn and perform essentially any intellectual task a human can, at a human level or better, and transfer what it learns between very different situations. There is no agreed test for AGI, and experts disagree sharply about whether and when it might arrive. Treat confident claims in either direction with caution.

Modern chat assistants blur the line because one model can write poems, explain tax rules and fix code. But breadth is not the same as general intelligence: these systems still fail in ways a person would not, as the next sections show.

What today's AI is good at

• Pattern-heavy language work: summarising, rewriting, translating, drafting, classifying and extracting information from text.
• Perception: recognising objects in images, transcribing speech, reading handwriting.
• Working at scale: doing the same kind of judgement thousands of times without getting tired.
• First drafts and brainstorming: producing many plausible options quickly for a human to choose from.
• Code: writing, explaining and fixing routine software, especially in popular programming languages.

What today's AI is bad at

• Guaranteed accuracy. A language model can state something false in a confident, fluent sentence. This is called a hallucination, and it is covered in depth later in the course.
• Knowing what it doesn't know. Confidence in the wording tells you little about whether the content is right.
• Recent events. A model learns from data collected up to a training cutoff date. Without extra tools, it has no knowledge of anything after that date.
• Exact counting and long precise reasoning without help from tools such as a calculator or code.
• Responsibility. An AI system cannot be held accountable for a decision. A person still has to own the outcome.

Common misconceptions

"It looks things up." A plain language model does not search the internet or a database when it answers. It generates text from patterns stored in its internal settings during training. Some products connect a model to tools such as web search or your files; then it can fetch information. Without such tools, it is answering from memory, and that memory can be wrong or out of date.

"It understands like a person." Models capture a great deal of real structure about language and the world, which is why they are useful. But they are not built to have experiences, feelings or intentions, and nothing in how they are designed makes them conscious. Whether any machine could ever be conscious is an open philosophical question; current systems are not designed with that goal, and fluent conversation is not evidence of it.

"It's an all-knowing oracle." Output quality depends on the training data, the instructions you give, and whether the task suits the system. The same assistant can be excellent at one request and wrong on the next.

"It's just autocomplete, so it's useless." This is the opposite mistake. Predicting the next word turns out to require learning a lot about grammar, facts and reasoning patterns, which is why these systems are genuinely capable at many tasks.

A concrete example

Imagine asking a chat assistant, with no web access, "Who won yesterday's match?" It has two options: say it cannot know, or produce a plausible-sounding answer from older patterns. Well-trained assistants increasingly do the first, but the second still happens. Now give the same assistant a web search tool: it can fetch a current result and quote its source. Same model, very different reliability, because of the tool, not because the model got smarter.

Going deeper

Four ways to define AI

The standard university textbook in the field, Russell and Norvig's Artificial Intelligence: A Modern Approach, organises definitions of AI along two questions. Should a system think or act? And should it be judged against humans or against an ideal standard of rationality? That gives four approaches:

The "acting humanly" corner is the oldest. In his 1950 paper "Computing Machinery and Intelligence", Alan Turing proposed replacing the vague question "Can machines think?" with an imitation game, now called the Turing test: can a judge, talking by text, reliably tell the machine from a person? Most modern engineering works in the bottom-right corner instead. We rarely want a system that copies human mistakes; we want one that does the job well.

The agent view

That bottom-right corner is usually described with the idea of an agent: anything that perceives its environment and acts on it. A spam filter perceives an email and acts by assigning a label. A chat assistant perceives the conversation so far and acts by producing the next piece of text or calling a tool. A robot vacuum perceives bumps and dirt and acts by moving.

A rational agent chooses the action that is expected to do best according to some measure of success, given what it knows. "Expected" matters, because the agent rarely knows for certain what will happen. The usual tool is expected utility: weight how good each outcome is by how likely it is, and add up.

$\text{EU}(a) = \sum_{s} P(s)\,U(a, s)$

Here $a$ is an action, $s$ ranges over the possible situations, $P(s)$ is the probability of situation $s$, and $U(a, s)$ is a score (the utility) for taking action $a$ when $s$ turns out to be true.

Worked example: the umbrella decision. The forecast gives a 30% chance of rain, so $P(\text{rain}) = 0.3$ and $P(\text{dry}) = 0.7$. Score the outcomes from 0 (worst) to 10 (best):

• $\text{EU}(\text{take}) = 0.3 \times 8 + 0.7 \times 6 = 2.4 + 4.2 = 6.6$
• $\text{EU}(\text{leave}) = 0.3 \times 0 + 0.7 \times 10 = 7.0$

Leaving the umbrella wins, narrowly. Now find the tipping point. Write $p$ for the chance of rain and set the two equal: $8p + 6(1-p) = 10(1-p)$, which simplifies to $12p = 4$, so $p = 1/3$. Above about a 33% chance of rain, take the umbrella.

Two lessons carry straight over to real AI systems. First, a "smart" decision needs both a model of the world (the probabilities) and an objective (the utilities). Second, the objective is chosen by people, and if it is wrong the system will faithfully optimise the wrong thing. A recommendation system scored only on clicks will learn to serve whatever gets clicked, which is not the same as what is good for the user.

Rules versus learning, in code

Here is the difference between a hand-written rule and a learned one, in a deliberately tiny example. Each email is reduced to one feature, the number of exclamation marks, with a label of 1 for spam and 0 for not spam.

# Each email: (number of "!" characters, 1 = spam, 0 = not spam)
emails = [(0, 0), (1, 0), (0, 0), (2, 0), (1, 0),
          (5, 1), (3, 1), (7, 1), (2, 1), (6, 1)]

def rule_based(count):
    return int(count >= 4)          # a threshold a person picked by hand

def learn_threshold(data):
    best_t, best_err = None, len(data) + 1
    for t in range(0, 11):          # try every threshold from 0 to 10
        err = sum(int(c >= t) != y for c, y in data)
        if err < best_err:
            best_t, best_err = t, err
    return best_t, best_err

t, err = learn_threshold(emails)
print("hand rule errors:", sum(rule_based(c) != y for c, y in emails))
print("learned threshold:", t, "errors:", err)

The hand-picked rule (flag emails with 4 or more "!") makes 2 mistakes: it misses the spam emails with 3 and 2 exclamation marks. The learning version tries every threshold and keeps the one with the fewest errors on the examples, landing on 2 with a single mistake (one genuine email with two "!" gets flagged; the threshold 3 also makes one mistake, and the code keeps the first best it finds). Nobody told the program what the threshold should be; it got it from data. That, scaled up to millions of examples and billions of adjustable numbers, is machine learning. The same toy also shows the danger: ten examples are far too few to trust, which is why the next lesson insists on testing with data the model has never seen.

Where the categories blur

Real products mix the boxes. A modern assistant might combine a generative model, a hand-written rule that blocks certain actions, a search engine and a calculator. It also helps to know one more split. A discriminative model learns to map an input to a label (spam or not spam). A generative model learns what the data itself looks like, well enough to produce new examples. A generative chatbot can still do classification by writing the label as text, which is one reason these models are used so widely.

Common pitfalls

• Treating "AI" as one technology. A rules engine, a trained classifier and a generative model fail in different ways. Ask which one you are dealing with before judging risk.
• Judging by the demo. A handful of well-chosen examples says little. Test on a representative sample of your own cases and count the errors.
• Confusing fluency with correctness, or breadth with generality. A system that writes well about everything is not therefore right about anything in particular.
• Forgetting the objective. A system optimises what it is measured on. If the measure is a poor stand-in for what you want, expect side effects.
• Assuming current knowledge. Without tools, a model knows nothing after its training cutoff.
• Anthropomorphising. Saying a model "wants" or "believes" something is a handy shorthand, but it can lead you to trust it like a colleague.

In practice

• When a product says "AI", ask which kind: rules, a trained classifier, or a generative model. The risks differ.
• Use generative AI for drafts, summaries and explanations, and verify anything that matters, especially names, numbers, dates and quotes.
• Check whether the tool you are using has web search or file access. If it doesn't, don't expect current information.
• Be sceptical of both hype ("it thinks like us") and dismissal ("it's just autocomplete"). The useful view is in between.