How is AI created?
Modern AI is created by training, not programming. Engineers collect huge datasets, define a network of billions of adjustable numbers called weights, then run trillions of guess-and-correct cycles on specialized chips until the weights encode useful patterns. Nobody writes the rules; the rules are found by repeated error correction.
Why — the first-principles explanation
Old software was written rule by rule: if the email contains 'free money,' mark it spam. That approach dies on any task where you can't enumerate the rules. Nobody can write down the rules for recognizing a cat, or for what word should come next in a sentence. So AI flips the direction. Instead of writing rules, you write a rule-shaped machine with millions of blank dials, then let data set the dials.
The machine is a neural network: layers of simple math operations, each with adjustable numbers called weights. Training works by prediction and punishment. Show it an input, let it guess the answer, measure how wrong it was (the loss), then use calculus — backpropagation — to compute which direction to nudge every single weight to make that error slightly smaller. Nudge them all a tiny amount. Repeat. Trillions of times. Each individual correction is nearly meaningless; the aggregate is a model that has absorbed the statistical structure of the data.
For a large language model, the training task is deliberately dumb: predict the next chunk of text. Read the entire internet, over and over, guessing what comes next. To get good at that, the network is forced to encode grammar, facts, styles, arithmetic, and something that behaves like reasoning — not because anyone asked for those, but because they're all useful for guessing the next word. That's pretraining, and it's where nearly all the money goes.
Then comes shaping. A pretrained model will happily continue any text, including terrible text. So labs run post-training: supervised fine-tuning on curated examples of good responses, and reinforcement learning from human (or AI) feedback, where humans rank outputs and the model is pushed toward the preferred ones. This is what turns a text-continuation engine into an assistant that answers questions and declines harmful requests. The intelligence largely comes from pretraining; the manners come from post-training.
The whole thing runs on specialized chips — GPUs and TPUs — because the core operation is multiplying enormous grids of numbers, and those chips do thousands of such multiplications at once. That physical fact is why AI became an infrastructure story: the math is old, the data is public, the bottleneck is silicon and electricity.
An example that makes it click
Picture teaching a kid to catch a ball, without ever explaining physics. You just throw. Miss. Throw again. Their hands drift a bit closer. Miss by less. Ten thousand throws later they catch it every time — and if you asked them to state the equation for a parabola, they'd have no idea.
That's training. The 'weights' are the settings in their arms and eyes. Nobody programmed the trajectory; the misses did it. Now scale it: instead of one kid and one ball, imagine a billion dials being nudged by a trillion missed throws, running on machines that can throw a million balls a second. That's an AI model.
How to do it
- Collect and clean data: text, images, code, or audio — often trillions of words, filtered for junk and duplicates.
- Choose an architecture: for language, a transformer with a set number of layers and billions of weights, all initialized randomly.
- Pretrain: feed data, have the model predict the next token, measure the error, and use backpropagation to nudge every weight. Repeat for weeks or months on thousands of GPUs.
- Supervised fine-tune: train on curated question-and-answer examples to teach the format of being helpful.
- Reinforcement learning from feedback: humans or AI rank competing outputs; the model is pushed toward preferred behavior and away from harmful behavior.
- Evaluate and red-team: test on benchmarks and adversarial prompts to find failures before release.
- Deploy and serve: run the frozen weights in a data center so users' prompts get answers — this is inference, and it's where most lifetime energy is spent.
Key facts
- Neural networks learn by backpropagation: computing the gradient of the error with respect to every weight, then adjusting weights slightly in the direction that reduces error.
- Large language models are pretrained on a self-supervised objective — predicting the next token — which requires no human labeling of the raw text.
- Post-training (supervised fine-tuning plus reinforcement learning from feedback) is what converts a raw text predictor into an instruction-following assistant.
- Training and serving run on specialized accelerators (GPUs/TPUs) because the core operation is large-scale matrix multiplication.
- Google reported the median Gemini Apps text prompt consumed 0.24 watt-hours and 0.26 mL of water in its May 2025 measurement, showing the per-use cost of serving a trained model.
- Google reported per-prompt energy fell 33x in 12 months (May 2024 to May 2025), with a 23x contribution from model improvements — evidence that efficiency comes largely from software, not just chips.
▶ The 60-second explainer (script)
AI isn't programmed. It's trained. Here's the difference. Old software was written rule by rule — if the email says "free money," it's spam. But nobody can write the rules for recognizing a cat, or for what word comes next in a sentence. So AI flips it. Instead of writing rules, engineers build a rule-shaped machine with billions of blank dials, called weights, and let data set them. Training is guess and correct. Show the model an input. Let it guess. Measure how wrong it was. Then use calculus to figure out which way to nudge every single weight to make that error slightly smaller. Nudge. Repeat. Trillions of times. It's like teaching a kid to catch a ball without ever explaining physics — you just throw, they miss, their hands drift closer, and ten thousand throws later they catch it every time and couldn't tell you the equation. For a language model, the training task is deliberately dumb: predict the next chunk of text, across the whole internet. To get good at that, the network is forced to absorb grammar, facts, and reasoning — because all of it helps guess the next word. Then labs fine-tune it with human feedback to make it a helpful assistant instead of a text-continuation engine. And all of it runs on specialized chips, because the math is just multiplying gigantic grids of numbers. That's why AI became a story about silicon and electricity.
What authoritative sources say
People also ask
Does anyone program the AI's answers?
No. Engineers program the training process and the guardrails, but the answers come from weights that were set by data and error correction. That's why even the builders can't fully explain a specific output.
How long does it take to create an AI model?
Pretraining a frontier model takes weeks to months on thousands of accelerators, then post-training and evaluation add more. Fine-tuning an existing open model can take hours on a single GPU.
What's the difference between training and inference?
Training sets the weights, once, at enormous cost. Inference uses the frozen weights to answer your prompt. Training is a big one-time bill; inference is a small bill paid billions of times.
Do AI models understand what they learn?
Contested, and genuinely unresolved. They demonstrably build internal representations that generalize beyond memorized text. Whether that constitutes understanding is a live scientific and philosophical debate, not a settled fact.
Can I create an AI myself?
You can fine-tune or run open models today on a normal PC. You cannot pretrain a frontier model — that requires a data center's worth of chips and a nine-figure budget.
The same question, asked other ways
- How is AI made?880/mo
- How was AI created?880/mo