Welcome to the awesome world of Artificial Intelligence

You have already used artificial intelligence a dozen times today. It unlocked your phone, sorted your inbox, guessed your commute, picked the next song and quietly checked that your last card payment was really you. You probably did not notice any of it — and that is the best sign of how deeply AI is now woven into ordinary life.

Then, in late 2022, AI stopped being invisible. Suddenly anyone could type a question in plain English and get back an essay, a poem, a working program or a patient explanation of quantum physics. The world noticed. Since then the pace has only picked up.

This is the first article in The AI World, a series on MSRX about how this technology works and what it means. We will start with no assumptions at all, and by the end we will be inside a transformer, reading its equations. Take it one section at a time.

What is AI, really?

Artificial intelligence is the craft of getting computers to do things that, if a person did them, we would say needed intelligence: recognising a face, understanding a sentence, planning a route, spotting a tumour on a scan, writing a reply.

For most of computing history, we made computers useful by writing out every rule by hand. To calculate tax, a programmer writes the tax rules. That works brilliantly when the rules are clear. But try writing the rules for “is this a photo of a cat?” Pointy ears? Some dogs have them. Whiskers? So do seals. Four legs? Not if the cat is curled up. You would never finish.

Modern AI flips the approach. Instead of giving the computer the rules, we give it examples — thousands of cat photos and thousands of not-cat photos — and let it work out the rules itself. That idea is called machine learning, and it is the engine behind almost everything called AI today.

AI, ML, deep learning, GenAI: the family tree

These words get used interchangeably in the news, but they are actually nested inside each other, like Russian dolls.

• Artificial Intelligence is the whole field — including old-school programs built from hand-written rules, like early chess engines and “expert systems”.
• Machine Learning (ML) is the part of AI that learns from data rather than following rules someone typed in.
• Deep Learning is the part of ML that uses neural networks with many layers. It took over around 2012, and it is what made speech recognition, face ID and modern translation work well.
• Generative AI is deep learning that creates new content — text, images, music, code, video — instead of only labelling things. Large language models (LLMs) such as ChatGPT, Claude and Gemini live here.

A 75-year story in two minutes

AI feels brand new, but the dream is older than the personal computer. The history is a rollercoaster of big promises, crushing disappointments (the “AI winters”) and, recently, breakthroughs that arrived faster than even researchers expected.

Notice the pattern after 2012. Three ingredients arrived at once: huge datasets (the internet), cheap parallel computing (graphics cards, GPUs, originally built for video games) and better algorithms. Neural network ideas from the 1980s suddenly worked, because we finally had enough data and compute to feed them.

Narrow, general and super AI

You will hear people argue about “AGI”. It helps to picture three rungs on a ladder.

A chess engine that beats every human alive cannot tell you what a chair is. That is narrow AI. Today’s large language models are strange in that they are wide — they can write, code, tutor and translate — yet they still make mistakes no careful person would, and they do not learn from experience the way you do. Whether scaling up the current approach reaches artificial general intelligence, or whether new ideas are needed, is genuinely open.

How machines learn

Machine learning comes in three main flavours, depending on what kind of feedback the machine gets while it learns.

There is also an important fourth idea: self-supervised learning. Here the data labels itself. Hide the next word in a sentence and ask the model to guess it; the real next word is the answer key. Since every sentence on the internet can be turned into practice questions this way, self-supervision unlocked training on truly vast amounts of text. It is exactly how large language models are pre-trained.

The machine-learning workflow

Whatever the flavour, real projects follow roughly the same loop. Beginners are usually surprised by how much of the work is data rather than clever algorithms.

Neural networks: brains made of maths

Neural networks are loosely inspired by the brain, but do not take the metaphor too far. An artificial neuron is a tiny calculator. It takes some numbers in, multiplies each by a weight (how much it trusts that input), adds them up with a bias, and squashes the result through an activation function.

On its own, one neuron is not very smart. Try it yourself: here is a single neuron deciding whether to take an umbrella.

The magic happens when you connect thousands or billions of them in layers. The first layer of an image network might learn to detect edges; the next combines edges into corners and curves; the next into eyes, wheels and letters; the last decides “cat” or “dog”. Nobody programs those features — they emerge from training.

How a network learns: loss, gradients and backprop

A freshly created network has random weights, so its answers are garbage. Training fixes that in a loop that repeats millions of times:

1. Forward pass. Feed in an example and get a prediction.
2. Measure the loss. A loss function turns “how wrong was that?” into one number. For classification the usual choice is cross-entropy: L = −log p(correct class). Confidently wrong answers are punished hard.
3. Backward pass (backpropagation). Using the chain rule from calculus, work out for every single weight how much the loss would change if that weight were nudged. That list of sensitivities is the gradient.
4. Update. Move every weight a tiny step in the direction that reduces the loss.

In practice nobody computes the gradient over the whole dataset at once. We use mini-batches of, say, 32 to a few thousand examples (stochastic gradient descent), and smarter update rules such as Adam, which gives each parameter its own adaptive step size. One full pass through the data is an epoch.

import torch
import torch.nn as nn

model = nn.Sequential(                 # a tiny neural network
    nn.Linear(784, 128), nn.ReLU(),    # 28×28 pixels in → 128 hidden neurons
    nn.Linear(128, 10),                # → 10 scores, one per digit 0–9
)
loss_fn = nn.CrossEntropyLoss()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    for images, labels in train_loader:
        logits = model(images.view(-1, 784))   # 1. forward pass
        loss = loss_fn(logits, labels)         # 2. how wrong?
        opt.zero_grad()
        loss.backward()                        # 3. backprop → gradients
        opt.step()                             # 4. gradient-descent step
    print(f"epoch {epoch}: loss {loss.item():.3f}")

Overfitting: the student who memorised the answers

A model with enough parameters can simply memorise its training data, noise and all. It then looks brilliant in training and fails on anything new. The opposite problem, underfitting, happens when the model is too simple to capture the pattern at all.

The defences are more (and more varied) data, regularisation (penalising extreme weights, or dropout, which randomly switches neurons off during training so none can be relied on too heavily), and early stopping when validation loss starts rising. Curiously, very large modern networks often generalise well even with enough capacity to memorise everything — a phenomenon researchers are still working to fully explain.

Architectures: the shapes of networks

How the neurons are wired matters as much as how many there are. Each architecture builds in an assumption about the data it will see.

Convolutional networks assume that a pattern is the same wherever it appears in an image, so they reuse one small filter everywhere. Recurrent networks assume data arrives in order, reading it one step at a time — which makes them slow and forgetful over long passages. The Transformer, introduced in 2017, dropped recurrence altogether: it looks at a whole sequence at once and lets every element decide which others to pay attention to. Because that work runs in parallel on GPUs, Transformers could be scaled to sizes nobody had tried, and they now dominate language, and increasingly vision, audio and biology.

Inside a large language model

Here is the most surprising fact in modern AI: a chatbot like ChatGPT or Claude is, at its core, a machine that predicts the next word. Just that. It reads your text and outputs a probability for every possible next token. One is chosen, stuck on the end, and the whole thing repeats. The fluency, the reasoning, the code — all of it emerges from getting extraordinarily good at that one game.

Step 1 — Tokens

Models do not read letters or whole words. Text is cut into tokens: common words are one token, rarer words are split into pieces. As a rule of thumb, one token is about three-quarters of an English word. A model’s context window — how much it can read at once — is measured in tokens, and today’s leading models handle hundreds of thousands of them, some a million or more.

Step 2 — Embeddings: a map of meaning

Each token ID is converted into an embedding, a long list of numbers (thousands, in large models). Think of it as a coordinate on a map with thousands of dimensions. Training arranges the map so that words used in similar ways end up close together — and, remarkably, so that directions on the map carry meaning.

Because the Transformer sees all tokens at once, it also needs to know their order, so a positional encoding is mixed into each embedding. Modern models typically use rotary position embeddings (RoPE), which rotate the vectors by an angle that depends on position.

Step 3 — Transformer blocks

The embeddings then flow through a stack of identical Transformer blocks. Each block has two parts: self-attention, where tokens share information with each other, and a feed-forward network, where each token is processed on its own. Residual connections carry the original signal around each part, which is what lets networks be stacked so deep without training falling apart.

Step 4 — Probabilities and sampling

After the last block, the final vector for the last position is turned into a score (a logit) for every token in the vocabulary, and a softmax turns those scores into probabilities. The temperature setting controls how adventurous the choice is. Play with it:

Attention, the maths

Read this sentence: “The animal didn’t cross the street because it was tired.” What does “it” mean? You instantly know it is the animal. Change “tired” to “wide” and “it” becomes the street. Working out which words matter to which other words is exactly what attention does.

Mechanically, every token’s vector is multiplied by three learned matrices to produce three new vectors:

• Query (Q) — “what am I looking for?”
• Key (K) — “what do I contain?”
• Value (V) — “what will I pass on if you pick me?”

Each token compares its query with every token’s key (a dot product: large when they point the same way). Those scores are scaled, turned into weights with softmax, and used to take a weighted average of the values.

Scale: why bigger kept winning

Around 2020 researchers found that a language model’s loss falls smoothly and predictably as you increase three things together: the number of parameters, the amount of training data and the compute spent. These scaling laws turned model building into something closer to engineering. DeepMind’s 2022 “Chinchilla” study refined the recipe: for a fixed compute budget, many models had been too big and undertrained, and roughly 20 training tokens per parameter was a better balance. Today’s frontier models are trained on many trillions of tokens.

How a chat assistant is made

A model that has only been pre-trained is a brilliant but unruly autocomplete. Ask it “What is the capital of France?” and it may well continue with “What is the capital of Germany?”, because in its training data, lists of quiz questions are common. Turning it into a helpful assistant takes further stages.

Reinforcement learning from human feedback (RLHF) deserves a closer look. People compare pairs of model answers and pick the better one. Those preferences train a separate reward model that predicts which answer a person would prefer. The chat model is then optimised to score highly with that reward model, with a penalty for drifting too far from its earlier self so it does not learn to game the scorer. Variants such as DPO skip the separate reward model and learn from the preference pairs directly, and some labs add AI-generated feedback guided by a written set of principles.

The newest step is reinforcement learning on verifiable tasks. Give the model maths problems and coding challenges whose answers can be checked automatically, and reward it only for getting them right. Models trained this way learn to write out a long chain of intermediate thinking before the final answer — trying approaches, catching their own mistakes, backtracking. That is what the “thinking” you see in reasoning models is.

Beyond text: images, voice and video

Most image and video generators use a different trick called diffusion. During training, you take real pictures and add a little random noise, then more, then more, until only static is left. The network’s job is to learn to reverse a single step: given a noisy image (and a caption), predict the noise that was added. Once it has learned that, you can start from pure static and denoise step by step, with your text prompt steering each step — and a brand new image appears.

The frontier is increasingly multimodal: single models that take in text, images, audio and video, and respond in several of them. The same core recipe applies — turn everything into tokens or embeddings, then learn the patterns — which is why progress in one area now spreads quickly to the others.

Putting AI to work: prompts, RAG and agents

Prompting well

A language model only knows what is in its training data plus what you put in the prompt. The single biggest improvement most people can make is to give it more context. Say who the answer is for, what good looks like, the format you want, and, when you can, an example.

RAG: giving the model your documents

A model does not know your company handbook, yesterday’s news or your private notes. Retrieval-augmented generation fixes that without retraining: split your documents into chunks, store their embeddings in a vector database, and at question time fetch the chunks closest in meaning to the question and paste them into the prompt.

Agents: models that act

An agent is a language model placed in a loop and given tools: web search, a code runner, a calendar, a company’s internal APIs. It decides on a step, calls a tool, reads the result, and decides the next step, until the goal is done. Coding assistants that read a codebase, run the tests and fix what fails are agents; so are assistants that research a topic across dozens of web pages.

Limits, risks and responsibility

AI is powerful, and it is also imperfect in ways that matter. A good user knows both.

Behind these everyday concerns sits a longer-term research field called AI safety and alignment: how do we make sure increasingly capable systems reliably do what we intend, are honest about what they do not know, and cannot be turned to serious harm? Interpretability researchers try to look inside networks and understand what individual neurons and circuits represent, so that we are not relying on a black box. Governments are writing rules too, such as the European Union’s AI Act. None of this is solved, and it is one of the most important open problems of our time.

Glossary

Quick quiz

Tap a question to check your answer.

Where to go from here

You now know more about how AI works than most people who use it every day. The best way to go further is to use it and build with it, a little at a time.

Coming up in The AI World: deeper dives into how large language models are trained, a hands-on guide to building your first RAG app, prompting techniques that actually work, what AI agents can and cannot do yet, and how to judge AI claims in the news.

Welcome aboard. It is an awesome world — and we have only just opened the door. 🚀

Numbers inside illustrations (probabilities, attention weights, token IDs, training output) are made up to show the idea. Spotted a mistake? Tell us.