AI vs Machine Learning vs Deep Learning

AI vs machine learning vs deep learning

These three words get used interchangeably, but they nest inside each other like Russian dolls.

AI: artificial intelligence›

Any technique that produces behaviour we'd call "intelligent." This includes old-school systems with no learning at all, hand-written rules, search algorithms, expert systems where a human encoded every decision.

ML, machine learning: The part of AI where the machine learns the rules from examples instead of a human writing them. You give it data and a goal; it figures out the mapping. (Classic ML like decision trees still beats fancy AI on lots of everyday data. Worth remembering.)

DL, deep learning: The part of ML that uses many-layered neural networks. Each layer learns to spot more abstract patterns than the last (letters → words → meaning). Today's language models are deep learning applied to text at enormous scale.

The nesting is true but it doesn't tell you much about behaviour. What actually predicts how a model behaves iswhere its learning signal came from, which is the next idea.

Try it yourself: Classify three tools you use daily›

Pick three AI-ish products you actually use: a spam filter, a phone's predictive keyboard, and a chatbot like ChatGPT or Claude. For each, guess: is it AI (rules), ML (learned from examples), or DL (deep neural net)? Most spam filters are classic ML; predictive keyboards and chat models are deep learning. No tools needed, just five minutes of thinking through what you already use.

Three ways a machine learns

The whole field runs on one question: where does the "correct answer" the model learns from come from, and what does it cost to get?

Style	Where the answer comes from	Cost	Used for
Supervised	Humans label each example by hand	Expensive; can't scale past millions	Teaching format & instruction-following
Self-supervised	The data labels itself: "predict the next word"	Nearly free; the whole internet is training data	The core of how models learn language
Reinforcement	A reward signal or human preference ("A is better than B")	Expensive per example, but shapes behaviour	Making models helpful, and teaching reasoning

Self-supervision is the trick that made modern AI possible. "Predict the next word" turns every piece of text ever written into a practice question with a known answer, no human labelling needed. Do that across trillions of words and the model absorbs grammar, facts, and reasoning patterns as a side effect. A handy debugging habit: when a model misbehaves, guess which stage caused it. Missing facts come from the first stage; excessive agreeableness comes from the "make it helpful" stage; its refusal style comes from the safety stage.

Try it yourself: Compare a labeled dataset to a self-supervised one›

Search for the ImageNet dataset and read how it was built: humans labeled each photo by hand. Then search for how GPT-style models are pretrained on web text. Notice the difference in who produced the 'correct answer': a paid human labeler in one case, the structure of the text itself in the other. That labor difference is why self-supervised learning scaled so much further.

Why this generation of AI won

Neural networks are decades old. Three things made them suddenly dominant in the 2020s:

The "bitter lesson."Over 70 years, general methods that simply use more computing power have always, eventually, beaten clever hand-crafted approaches. Betting on scale kept winning.
The transformer fits the hardware. The transformer (the architecture behind every modern model) does its work as huge parallel matrix multiplications: exactly what GPUs are built for. Older designs processed text one word at a time and couldn't keep a GPU busy. The transformer won on hardware efficiency, not elegance.
Scaling became predictable. Researchers found that a model's error drops in a smooth, forecastable curve as you add parameters, data and compute. That turned "train a giant model" from a gamble into a budgeting exercise, which is why the money flooded in.

And a myth to drop: "scaling has stopped." It didn't stop, it moved. Instead of only making models bigger, labs now also let themthink longerat answer time, use "mixture-of-experts" tricks, and have big models teach small ones.

Try it yourself: Feel the scale jump›

Look up the parameter count of GPT-2 (2019, ~1.5 billion) and a current frontier model (often 100B+ or undisclosed but estimated far higher). Then look up roughly how training compute cost has grown over the same years. The 'bitter lesson' isn't an abstraction, it's this specific curve.

Generative vs agentic vs autonomous

Three words that vendors love to blur. The distinction is genuinely important:

Generative AI produces an artifact when you ask: text, an image, some code. It has no memory and takes no actions; you do everything with its output.
Agentic AI wraps that same model in a program that gives it tools, memory, and a loop, so it can take actions in the world and react to the results, with a human supervising.
Autonomous AI is an agentic system allowed to start itself (on a schedule or an event) and act within set limits, where humans handle only the exceptions.

The key insight:"agentic" is about architecture (does it have tools and a loop?), while "autonomous" is about policy (what are you allowing it to do without asking?). The exact same code is a careful copilot if writes need approval, and an autonomous agent if they don't. When someone says "autonomous AI," ask, which actions run without a human, and what triggers them?

A more useful scale, borrowed from self-driving cars, helps place any workflow by how much you trust it:

L0Generation only. The human does everything with the output.

L1Uses tools, every action confirmed. A copilot.

L2Reads freely, writes need approval. The sane enterprise default.

L3Writes run automatically within limits. Humans handle exceptions and review samples.

L4Starts itself, checks itself, escalates only on anomalies.

L5Sets its own goals across domains. Doesn't really exist yet, treat claims with suspicion.

Every step up trades less human review for a bigger blast radius if things go wrong. The honest way to decide where a task belongs is arithmetic, not vibes:how often does it fail × how bad is a failure, versus the review effort you'd save. This exact frame drives every decision in the IAM section later.

Try it yourself: Place your own AI tools on the ladder›

Take three AI tools you've used: say, ChatGPT for writing, an IDE autocomplete, and an autonomous coding agent (if you've tried one). Place each on the L0–L5 ladder from the diagram above, and write one sentence justifying each placement: does it act without confirmation? Does it chain multiple steps on its own?

The reliability math nobody mentions

Here's a sobering bit of multiplication. If an agent is 98% reliable on a single step, and a task takes 20 steps in a row, its success rate for thewhole taskis 0.9820≈67%. Reliability compounds downward, fast. Three consequences shape everything: long tasks depend on per-step reliability far more than on how "smart" the model is; it's better to design for cheap detection-and-retry than to assume steps succeed; and you should build for the model you'll haveat deployment, because the length of task models can handle has been roughly doubling every several months.

Try it yourself: Run the compounding math yourself›

Calculate 0.95^10, 0.98^10, and 0.99^10 (any calculator works). Notice how a 4-point difference in per-step reliability (95% vs 99%) produces roughly a 30-point difference in whether a 10-step task actually completes. This is why 'the model is 98% accurate' is a much weaker claim than it sounds for anything multi-step.