What is AI?

1Three nested ideas

Artificial intelligence is the engineering goal of systems that act usefully when the correct behaviour is not written down anywhere: planning a route through traffic, ranking a feed, reading a handwritten form. The term names an ambition about behaviour, and says nothing about how the behaviour is produced.

Machine learning is one family of methods inside that ambition. Instead of a programmer writing the behaviour as explicit rules, the behaviour is fitted: a parametrised function is adjusted until its outputs agree with examples. The defining property is that performance improves with data rather than with more authored rules.

Deep learning is in turn one family of methods inside machine learning: the fitted function is a neural network with many layers, whose intermediate representations are themselves learned. It dominates when the input is a large raw signal — images, audio, text — precisely because hand-designing features for such signals is what it removes.

The three terms therefore nest rather than compete. A chess engine that searches a game tree is AI without ML; a decision tree fitted to loan records is ML without deep learning; a transformer language model is all three at once.

The nesting matters operationally because each ring has a different cost profile: rules need an author who knows the policy, learning needs representative data and an evaluation, and deep learning additionally needs scale — in data, compute and engineering — before it beats the simpler rings.

Figure. Three nested sets, not three rivals: every deep-learning system is machine learning, every machine-learning system is AI - but each outer ring holds members the inner one does not (hand-written rule systems are AI without ML; decision trees are ML without deep nets).

2Four definitions of intelligence

Before the field settled on an engineering stance, 'is it intelligent?' had four working definitions, and they still organise the textbook debates. A system can be judged on whether it thinks or merely acts, and against a human standard or a rational one — two axes, four quadrants.

Acting humanly is the Turing test position (1950): if interrogators cannot reliably distinguish the machine's conversation from a person's, the machine passes. It is a landmark and a poor engineering target — aeronautics did not advance by building machines that imitate pigeons convincingly.

Thinking humanly is the cognitive-modelling programme: build systems whose internal steps match measured human reasoning, errors included. Valuable to psychology; rarely what a production system wants, since human error is a feature to model there and a defect to ship here.

Thinking rationally is the logic tradition: encode knowledge as formal statements and derive conclusions that are provably entailed. It gives guarantees, and it struggles with noisy, unformalised input — which is most input.

Acting rationally — do whatever maximises expected success given the available evidence — is the definition modern AI engineering actually uses, because it is the one you can specify a measure for, optimise against, and audit. The rest of this course sits in that quadrant.

Figure. Two axes give four definitions: match human thought, derive provably correct conclusions, pass for a person, or act to maximise expected success. Modern AI engineering lives in the acting-rationally quadrant because it is the one with a specifiable, measurable target.

3Rationality and the performance measure

The acting-rationally quadrant has a precise core: an agent is rational if it selects actions that maximise the expected value of its performance measure, given the percept sequence so far and whatever knowledge it carries. Every word in that sentence is load-bearing.

Expected, because the environment is uncertain and rationality is judged before the dice land: a poker agent that plays the odds correctly and loses the hand was still rational. Rationality is not omniscience, and a correct decision is not the same thing as a good outcome.

Performance measure, because someone must say what success is — as a function of the environment's state, not of the agent's beliefs about it. An agent graded on its own confidence will learn confidence.

The measure is where practical systems fail first. A vacuum agent scored on dirt sucked per hour is rational to dump dirt and re-suck it; a recommender scored on clicks is rational to serve outrage. The optimiser did exactly what was asked — the specification was wrong. In production this failure family is called reward hacking or specification gaming, and it is a defect of the measure, not a bug in the optimiser.

So the engineering habit this course will keep returning to: write the measure down, ask what a perfect optimiser of it would do in the worst case, and only then optimise. The later lessons on evaluation and governance are this sentence expanded.

Figure. Success is a state of the environment — dirt actually gone, fraud actually stopped — never the agent's own report of it. An agent graded on its own confidence will learn confidence. The number moves only when the world changes state.

Designing the measure

1. Score the worldDefine success as a state of the environment — dirt actually gone, fraud actually stopped — never as the agent's own report of it.
2. Stress-test itAssume the optimiser is smarter than you and adversarial: what maximises this number while betraying its intent?
3. Then optimiseFix the measure first. An optimiser pointed at a bad measure gets you the bad thing, efficiently.

4Narrow AI versus the general story

Narrow AI names a system built, trained and scored for one task, on one metric, in one operating context. The spam filter, the chess engine, the fraud model — each is a statement about a single distribution of inputs.

Skill measured on one distribution does not travel. The 99%-accurate spam filter knows nothing about support tickets; more subtly, it degrades on its own task when the inputs drift — new campaigns, a different language mix, adversaries adapting. Distribution shift, not lack of cleverness, is the standard failure mode of deployed narrow systems.

The mechanism deserves a precise statement: a fitted model encodes regularities of its training distribution, and every guarantee attached to it is conditional on future inputs resembling that distribution. Change the distribution and the guarantee is void — silently, because the model still emits confident outputs.

Artificial general intelligence — competence with human breadth across tasks the system was never specifically engineered for — remains a research ambition with no agreed measurement. A claim about it is not an engineering claim until it comes with an evaluation you could run.

The working discipline: for any system described as 'AI-powered', ask which task, which metric, which operating context, and what evidence exists off-distribution. Those four questions separate an engineering artefact from a press release.

Picture three sealed boxes, each wired to exactly one input stream and one scoreboard. Lift a box onto a different stream and the scoreboard does not drop — it disconnects: the number it showed was a fact about the old stream, not about the box.

5The map of methods

AI is a portfolio of method families, and choosing among them is the first design decision of any system. Four families carry most of the field, and each is the rational choice under different knowledge conditions.

Search and planning apply when you can write down the states, the legal moves and the goal: the method computes the action sequence from the specification, and no data is needed. Logic and knowledge representation apply when the domain has hard constraints that must never bend, and what you want is entailment — conclusions guaranteed by the premises.

Probabilistic reasoning applies when evidence is noisy and belief must be graded rather than binary; Bayes' rule is its engine. Learning applies when the mapping you need cannot be written down at all, but examples of it are plentiful.

The families compose rather than compete: a route planner searches over a map that a learned system perceived; a fraud stack learns a score and gates it with logical constraints. Reading a production system means naming which family owns which component.

This course walks the families in that order — uninformed search, cost-aware search, heuristics, logic, uncertainty and Bayes — before the dedicated ML and deep-learning courses take the learning family apart.

Figure. One task, four method families, and the edge labels are the decision: if the moves are writable, search; if the constraints are hard, logic; if the evidence is noisy, probability; if the mapping cannot be written but examples exist, learning. Production systems usually take more than one edge at once.

6Where foundation models sit

Large language models complicate the narrow-versus-general story without resolving it. A foundation model is a deep network trained once on a broad corpus and then applied, with light adaptation, to many tasks — one artefact now covers translation, code and question answering at once.

In the taxonomy, nothing moved: the artefact is deep learning, therefore machine learning, therefore AI. What changed is the packaging — breadth of task coverage from a single training run, which older narrow systems never had.

Breadth is not generality in the research-ambition sense, and the difference is measurable: capability is established per task, per context, by evaluation, and reliability, latency and cost are properties of the deployment rather than of the weights. A model that clears a benchmark can still be the wrong component for a system whose inputs look nothing like the benchmark.

Production practice therefore treats a foundation model as a component inside an engineered system — wrapped in retrieval, tools, guardrails and an evaluation harness. The surrounding lessons of this course, on agents, hybrid stacks and measurement, are exactly the engineering that decides whether the wrapped model ships.

The claim discipline from the previous concept applies unchanged: 'the model can do X' is an engineering statement only when it names the evaluation, the distribution it ran on, and the score.

On the nested-set map from the Three nested ideas figure, a foundation model is a point in the innermost deep-learning ring. Its breadth changes how many applications draw arrows to that point — not which ring it lives in.