Three years ago, "AI" meant a chatbot that could barely hold a conversation. Today, a single model can draft your emails, debug your code, translate a contract, and write a sonnet about your dog — all without being retrained for any of it. That shift has a name: the Large Language Model, or LLM.
This post breaks down what an LLM actually is, why it became the dominant form of AI almost overnight, how it's built, and the architecture — the Transformer — that makes the whole thing possible.
A Large Language Model is a neural network trained on massive amounts of text that learns to understand, generate, and respond to human language.
Break the name down and it explains itself:
Everything an LLM does — writing, summarizing, translating, coding, reasoning — comes down to one core skill repeated at enormous scale: predicting what text should come next.
To understand why LLMs feel like such a leap, it helps to look at what came before them.
Classical NLP (Natural Language Processing) systems were narrow by design. You'd build one model to translate French to English. A completely different model to detect sentiment in product reviews. Another one for spam filtering. Each was trained from scratch, on its own dataset, for its own task.
Ask that translation model to write a polite decline email, and it simply couldn't — that capability was never built into it. Extending it meant building an entirely new model.
| Classical NLP | Large Language Models | |
|---|---|---|
| Scope | One model, one task | One model, hundreds of tasks |
| Training | Task-specific dataset from scratch | General pretraining, then adapted |
| Flexibility | Rigid — new task = new model | Prompted, fine-tuned, or extended |
| Example use case | A translation-only engine | Translation, coding, writing, Q&A, analysis — all in one |
Here's the discovery that changed everything: if you train a large enough model to do one deceptively simple task — predict the next word in a sentence — the same architecture turns out to be shockingly good at translation, summarization, question-answering, reasoning, and dozens of tasks nobody explicitly trained it for.
That generality is the whole story. A narrow NLP model has a limited use case. An LLM has, practically speaking, an endless use case — the same weights that write poetry can also explain your tax return.
These terms get thrown around interchangeably, but they describe nested categories, not synonyms.
Artificial Intelligence └── Machine Learning └── Deep Learning └── Large Language Models
Generative AI sits slightly to the side of this hierarchy rather than at the bottom of it. It's best described as deep learning (including LLMs) applied to generation — producing new text, images, audio, or video rather than just classifying or predicting a label. An LLM is a specific, text-only application of generative AI's broader idea: using deep neural networks to create human-like content.
The realistic answer is: almost everywhere text is involved. A few of the biggest categories:
New use cases show up constantly, which is really the point: the model doesn't need to be redesigned for each one.
Building an LLM happens in two very different phases.
The model is trained on a huge, diverse, mostly unlabeled corpus of text — books, websites, articles, code repositories, forums. It isn't taught to do anything specific; it just learns the statistical structure of language: grammar, facts, reasoning patterns, style.
The result is a foundation model — general-purpose, capable, and expensive to create. This stage is where nearly all the cost lives. Independent estimates put the compute cost of training GPT-3 (175 billion parameters) at roughly $4–5 million; more recent frontier models have run into the tens or even hundreds of millions of dollars once you factor in larger clusters, longer training runs, and repeated experimentation. Pretraining is squarely a "only a handful of organizations can afford this" activity.
Once you have a foundation model, you don't need to repeat that expensive process to make it useful for a specific job. Instead, you fine-tune it — continue training on a smaller, task-specific, labeled dataset. This is dramatically cheaper and turns a generic text predictor into a specialized assistant, translator, classifier, or support agent.
[Internet text, books, articles, code] │ ▼ PRETRAINING (unlabeled data, huge cost) │ ▼ Foundation Model (general capability) │ ▼ FINE-TUNING (labeled data, targeted, cheap) │ ▼ Personal assistant │ Translator │ Summarizer │ Classifier │ ...
If pretraining and fine-tuning are the process, the Transformer is the engine. It was introduced in the 2017 paper "Attention Is All You Need," published by researchers at Google Brain, and it was originally built for one specific job: machine translation, initially between English, German, and French.
Nobody involved fully anticipated that this architecture would become the backbone of nearly every major LLM built since — GPT, BERT, and their descendants all trace back to it.
At a high level, a Transformer built for translation moves through eight stages:
In short, the architecture has two halves with distinct jobs:
The mechanism that makes all of this work is self-attention. In plain terms, self-attention lets the model weigh how relevant every other word in a sentence is to the word it's currently processing.
That sounds abstract, so consider a sentence like "The trophy didn't fit in the suitcase because it was too big." What does "it" refer to — the trophy or the suitcase? A human reader resolves this instantly by relating "it" back to "trophy" using context from across the whole sentence. Self-attention gives a model that same ability: it can connect a word to any other word in the input, no matter how far apart they are, and decide how much each one matters.
This is what earlier architectures struggled with. Older sequence models processed text strictly left to right, one word at a time, which made it hard to capture relationships between distant words and slow to train because nothing could happen in parallel. Self-attention lets a Transformer look at an entire sequence at once and figure out long-range dependencies directly — which is also why Transformers train dramatically faster on modern hardware.
"All Transformers are LLMs." Not true. The Transformer architecture is domain-agnostic — it's also used heavily in computer vision, for tasks like image classification and image segmentation. An LLM is just one application of the Transformer, not the only one.
"All LLMs are Transformers." Also not true, and less obvious. "Large Language Model" describes a model's scale and purpose (huge, trained on language), not a specific architecture. Before Transformers dominated, language models were built on recurrent neural networks (RNNs), Long Short-Term Memory networks (LSTMs), and even convolutional architectures. Those approaches are largely out of fashion for frontier models today because they don't parallelize as well as self-attention, but the "LLM" label doesn't strictly require a Transformer under the hood.
"Bigger pretraining data automatically means a better assistant." Pretraining gives a model broad capability, but raw capability isn't the same as usefulness for a specific job. That gap is exactly what fine-tuning closes — it's the difference between a model that merely predicts plausible text and one that reliably follows instructions or classifies your support tickets correctly.
Key takeaways:
The Transformer paper's title was "Attention Is All You Need." Nearly a decade later, that claim has held up remarkably well — and it's the reason the model answering your questions today can also translate your emails, write your code, and explain itself while doing it.