You've probably read that "a vector is just a list of numbers." True, but unsatisfying — it tells you the shape without telling you why things end up in that shape, or what the numbers are doing there. It's the kind of sentence that leaves embeddings feeling like voodoo.
So let's not take it on faith. Let's build a vector by hand, from scratch, where every number means something you chose on purpose. Once you've made one yourself, the shape stops being arbitrary — and you'll see exactly why the fancy learned ones look the way they do.
Describe some animals with numbers
Suppose you want to capture a few animals as numbers. You pick some properties and score each animal on each one. Nothing clever — just measurements you make up:
- weight (in kg)
- legs (how many)
- furriness (0 = bald, 1 = very furry)
- domesticated (0 = wild, 1 = pet)
- flies (0 = never, 1 = expert flier)
Now you fill in the table:
- dog →
[30, 4, 0.9, 1.0, 0.0] - cat →
[4, 4, 0.9, 0.9, 0.0] - trout →
[1, 0, 0.0, 0.0, 0.0] - eagle →
[5, 2, 0.2, 0.0, 1.0] - sparrow →
[0.03, 2, 0.3, 0.1, 1.0]
That's it. Each row is a vector. Each number means precisely what you decided it means — the third slot is always furriness, for every animal. There's no magic here at all; it's a spreadsheet.

The similarity was free
Now look at the rows and notice something you didn't explicitly build in. The dog and cat rows look a lot alike — both middleweight, four-legged, furry, tame. The eagle and sparrow rows also resemble each other — light, two-legged, flying. The trout row doesn't look like any of them.
You never wrote a rule that says "dogs and cats are similar." It fell out on its own, the moment you described everything with the same measurements. Animals that are alike ended up with rows that look alike — numbers close to each other, slot by slot.
That is the entire trick of vectors, and you just did it by hand. "Find similar things" becomes "find rows whose numbers are close." Closeness of the numbers stands in for similarity of the things. Everything a vector database does is built on that one substitution.

Why the shape has the rules it has
This little exercise also explains the two rules that make a vector a vector, and not just a pile of numbers:
Every item uses the same slots, in the same order. Furriness is always the third number — for the dog, the trout, the eagle, all of them. That's not fussiness; it's the whole point. It's what lets you line two animals up and compare them slot by slot: dog's furriness against cat's furriness, dog's legs against cat's legs. If everyone used different columns in a different order, "compare these two" would be meaningless. A fixed-length, fixed-order list is exactly the shape that makes comparison possible.
More slots means finer distinctions. Right now your dog and cat rows are nearly identical — the table can barely tell them apart. Add a column, say nocturnal (0 to 1), and suddenly a gap opens: cat 0.7, dog 0.2. Every property you add is another way for two things to differ, another axis to separate them along. This is what people mean by the number of dimensions of a vector: it's just how many measurements you're keeping. More dimensions, more room to capture nuance — at the cost of more numbers to store and compare. (There's more on that trade in Vector embeddings 101.)
So the shape isn't a convention someone imposed. It's forced by the job: describe everything with the same ordered set of measurements, and comparison — the thing you actually want — comes for free.

Where hand-building falls apart
Here's the catch, and it's the reason we need the fancy stuff. Your animal table worked because you knew which properties mattered and there were only a handful of them. Weight, legs, furriness — easy to name, easy to score.
Now try to do the same for the meaning of a sentence. What are the columns? "Formality"? "Is-it-about-food"? "Emotional-tone"? You could brainstorm for a week and never finish, because meaning has thousands of dimensions and most of them you'd never think to name. Try it for what's in a photograph and it's worse. Hand-picking the properties, which was trivial for five animals, becomes impossible for language or images.
So we don't. Instead of choosing the columns ourselves, we hand that job to a model: show it enormous amounts of text (or images), and let it invent its own set of measurements — far more of them than you'd pick, and far better tuned to the data than you could manage. The result is the same shape you built by hand — a fixed-length, fixed-order list of numbers — just with columns discovered by a machine instead of chosen by you.
How a model comes up with those measurements is its own story: how a computer learns what words mean. And there's a twist waiting — the columns it invents turn out to be enormously useful but impossible to read, which is a puzzle worth its own page: why you can't read a vector.
Closing
A vector isn't a mysterious object. It's a row in a spreadsheet: describe every item with the same ordered list of measurements, and "are these two things alike?" turns into "are these two rows close?" You just built one by hand and watched similarity appear on its own.
Everything that follows — the 384-number embeddings, the billion-item searches — is that exact idea, scaled up, with one change: a model picks the measurements instead of you. The shape never changed. Only who fills it in.
