Someone else's, all the way down
We call it automatic and ours. Below the model sit the people who labelled its data; above it sits a foundation model you rent rather than own.
A model passes between two hands that never touch — held up from below, taken from above, and yours at neither end.
There is a kind of magic trick that works better the less you look at how it's done. A message lands in your spam folder and you never see it. A chatbot drafts your email in seconds, in prose that reads like a person's. We have a word for all of it, and the word is automatic. It is a good word for selling software and a bad word for understanding it, because at every level the automatic thing turns out to be made of people and property that are not yours.
This is one essay in two directions. First we look down, into where these systems came from, and find human hands where the story promised none. Then we look up, at what it means to build a product on top of them, and find the same shape inverted: value and risk living in a layer you don't own. The machine you are using is, in the most literal and the most economic sense, someone else's — all the way down.
Part I — Where AI comes from
From rules to examples
Start with the least glamorous AI ever shipped: the spam filter. In 2002 Paul Graham published A Plan for Spam. He had spent six months writing rules by hand — suspicious words, capital letters — and found that "recognizing that last few percent of spams got very hard." Then he stopped writing rules and instead fed a program examples: a corpus of some four thousand spam messages and four thousand legitimate ones, and let probability work out the patterns. The result, he admitted, "was much cleverer than I had been." It found signals he would never have thought to encode.
That is the whole idea of machine learning, and everything since is a variation on it: you do not program the behaviour, you provide examples and let the system infer the rules.
Scale beats cleverness
In 2012 the approach had its coronation. A neural network called AlexNet won the field's image-recognition contest by a margin that ended the argument — a top-five error around fifteen percent, some eleven points better than the runner-up — not with cleverer rules but with a deep network, GPUs, and an enormous pile of labelled images. The lesson the field drew was intoxicating: scale beats cleverness.
Feed a big enough model enough examples and it learns what no one could hand-code. Hold on to the phrase "labelled images." We will come back to who did the labelling.
The machine that "teaches itself"
Then the examples seemed to vanish. Today's large models are trained by self-supervision: instead of labelled data, they learn from raw text by predicting the next word, over and over, across most of what has ever been written. The objective is so simple it sounds like a trick — and it is, almost exactly, the game Claude Shannon played by hand in 1951, measuring the entropy of English by having people guess the next letter.
Shannon, 1951: how hard is the next letter to guess? He measured the entropy of English by hand. A language model is that same game — next-symbol prediction — played at planetary scale.
Out of that, at enough scale, comes what Stanford's researchers named in 2021 the foundation model: trained on broad data, adaptable to almost anything. Self-supervision, as Chip Huyen puts it, "helps overcome the data labeling bottleneck," because each sequence of text is its own answer key. The labels, the field told itself, are no longer hand-made. The machine finally teaches itself.
Except it doesn't. It never did.
The hands beneath
AlexNet did not spring from raw pixels. It ran on ImageNet — some fourteen million images sorted into around twenty-two thousand categories — and every image was labelled by a person. Fei-Fei Li's team built it, by her own account, on Amazon Mechanical Turk: tens of thousands of workers across a hundred and sixty-odd countries, judging, a penny at a time, whether this was a "balloon" or a "monkey." The self-teaching machine stood on a scaffold of piecework assembled by people whose names appear in no citation.
And the web made the same demand at a far larger scale. Every platform that lets a billion people post inherits everything a billion people will post, and someone has to decide what stays up. Sarah T. Roberts, who named this work commercial content moderation, estimates more than a hundred thousand people do it worldwide.
In 2019 Casey Newton documented one site — a Cognizant contract running Facebook's moderation in Arizona, workers earning about fifteen dollars an hour to absorb, image by image, the worst of the internet, many left with symptoms of trauma. A year later Facebook paid fifty-two million dollars to settle a lawsuit by moderators who developed PTSD. Around fifteen thousand people did this for Meta alone — almost none employed by Meta, but by Accenture, Cognizant, Sama: the labour kept at arm's length, on someone else's payroll, in someone else's country.
Ghost work
Mary Gray and Siddharth Suri gave the pattern its sharpest name — ghost work — and its sharpest law: the paradox of automation's last mile.
Automation is not a finish line but a moving frontier; each task it removes throws off new tasks that still need a human judgement, so it perpetually generates hidden human labour rather than ending it. Astra Taylor calls the ideological cover fauxtomation: the illusion of intelligent machines, kept up by making the people inside them invisible.
The snake eats its tail
Here the story closes a loop. The promise of this wave of AI is that it can finally automate the judging-at-scale the web made necessary. And to build the model that makes the promise, its makers reached for the same kind of labour they were promising to replace. In January 2023, Time's Billy Perrigo reported that OpenAI, to make ChatGPT less toxic, had paid workers in Kenya — after fees, roughly one to two dollars an hour — to read and label the most harmful text imaginable, so a classifier could learn to filter it out. (To be precise: this fed the safety filter, not the preference-ranking of RLHF — but it belongs to the same human pipeline behind every "aligned" model.) Humans were paid almost nothing to steep themselves in the worst of what humans produce, so a machine could be sold as the thing that spares us from having to.
From Graham's spam corpus in 2002 to the toxicity labels in Nairobi in 2022, the arc is unbroken. The "automatic" was never self-feeding. It has never run on its own: every system that appears to learn, filter and improve by itself is, underneath, being fed and corrected by people — continuously, not once at the start. Calling it automatic has only ever been a way of not looking at them: of pushing the labour down, and out, and somewhere you were not expected to see.
Part II — How AI actually gets built
You are not building the model
Suppose you are not training these models — and you almost certainly are not. You are a team trying to put some of this capability into a product, and what you feel is a quiet impostor's anxiety: we're just calling an API; the real innovation is elsewhere; are we even doing AI? It's worth naming that feeling in order to dismiss it, because it marks a real and newly-drawn line.
There is a discipline for what you are doing — Chip Huyen calls it AI engineering — and its founding premise is a relief and a demotion at once: you build on foundation models; you do not build them. In 2026 it is entirely normal for a company "doing AI" to never touch the frontier innovation. That is not a lack of ambition. It is the shape of the field.
What a foundation model actually is
It helps to be concrete about the thing you're building on. A foundation model is what you get when self-supervision is run at enormous scale over the open web — Common Crawl and the rest — until a single model is general enough to adapt to almost any task.
Its making, Huyen notes, splits in two: pre-training makes the model capable but not safe or easy to use; post-training (instruction-tuning, human feedback) makes it usable and aligned. The training data is the tell — a model can only do what its data prepared it for — which is why what a lab will and won't disclose about that data has become such a fight. It is, in the end, a pressed record you can own but not read: a few gigabytes of frozen statistics that say nothing about the studio that cut them.
The two-step making. Pre-training builds raw capability from the open web — some 98% of the compute. Post-training, a sliver of the cost, adds the manners: supervised finetuning and human-preference tuning. Note where the hands re-enter — the same labelling economy from Part I, now one floor up.
Frontier vs. open weights
The real choice you face is not "which benchmark won this month" but which kind of model to build on. On one side, frontier models — OpenAI, Anthropic, Google — the most capable, reached only through an API you rent. On the other, open-weight models — Llama, Mistral, DeepSeek, Qwen — which you can download and run yourself. The distinction that trips everyone up: open weights are not open source. You are handed the pressed disc, not the recording studio — the numbers, not the data or the process that produced them.
Frontier buys you capability and hands you a dependency; open weights buy you control, privacy and a fixed cost, and hand you the bill for running them. I spent a month running open models on my own laptop precisely to feel where that line falls — and it falls in a different place for the model, the server and the harness. Choosing among them is the first real act of AI engineering, and it is a trade of capability against control, not a search for the "best" model.
The three layers
Huyen draws the discipline as three layers, and the surprise is where the work actually lives.
Huyen's three layers of the AI engineering stack. For most teams the differentiation lives in the top layer — and even in the middle one, the weight is on data and evaluation, not raw inference.
At the top is application development — prompts, the context you feed the model, rigorous evaluation, and a good interface. This is the layer that has seen the most action, and for most teams it is where the differentiation lives.
In the middle, model development — modelling, training, finetuning, inference optimisation, and, centrally, dataset engineering; even here the weight has shifted toward data and evaluation, away from raw inference.
At the base, infrastructure — serving, compute, monitoring — the part that, tellingly, has changed least. If your team lives in the top layer, it is not doing a lesser kind of AI. It is doing the kind where products are actually made.
Borrowed ground I — differentiation
But building at the top of someone else's stack means your differentiation is held on loan, and there are two ways to lose it. The first is that the platform simply absorbs what you do.
Apple did this so reliably to third-party apps that developers coined a verb — sherlocked, after the 2002 release in which Apple's Sherlock swallowed the features of a beloved app called Watson; the 2024 keynote alone quietly folded in a dozen independent apps. The AI version arrived fast: Jasper reached a $1.5-billion valuation as a polished layer over OpenAI's API, and weeks later ChatGPT shipped free — by mid-2023 there were layoffs and a valuation markdown. The feature you ship this quarter can be a built-in next quarter, folded into the platform, gone.
Borrowed ground II — the toll
The second way is quieter: you don't own the engine, so you rent it by the token. Andreessen Horowitz noted as early as 2020 that AI companies tend to run gross margins of 50–60%, against the 60–80%+ of ordinary software, because compute sits in the cost of goods rather than in fixed R&D. When you buy an API you pay the provider's list price — the markup already inside it — never at cost. Your margin lives, permanently, on someone else's pricing table, and every unit of success pays a toll upward.
The oldest risk, one floor up
If this feels familiar, it should, because the web has run it before. For two decades an entire economy grew in the gravity of one company's search ranking; businesses optimised their whole existence around it. Then in February 2011 Google's Panda update, aimed at "content farms," erased the traffic of the poster child — Demand Media's eHow, fresh off a $1.5-billion IPO — almost overnight.
Ben Thompson's Aggregation Theory is the law beneath it: the platform that owns the user relationship turns its suppliers into commodities that "come onto the aggregator's platform on the aggregator's terms." Depending on a foundation model is that same bargain moved one floor up the stack — Google's index became OpenAI's weights — and it is the defining condition of the web as a connected fabric: the thing that feeds you is also, structurally, the thing that can annul you, because it was never yours.
Someone else's, all the way down
So the machine is someone else's in both directions. Look down and the labour that taught it is someone else's — externalised onto workers you were not meant to see, its cost in fifteen-dollar hours and settled lawsuits. Look up and the capability you build on is someone else's — externalised onto a platform you don't own, its risk in differentiation you can lose and margins you don't set. The word that stitches the two views together is externalisation: the AI you actually encounter is a tall stack of things that live where you are not, held together by everyone's willingness to call it automatic and leave it there.
None of this is a reason not to build. It is a reason to build with your eyes open, which is the only kind of building that ages well. The craft — for whoever directs product and technology through this — is not to pretend the stack is yours, nor that it is automatic, but to see your dependencies clearly and to hold the layer you actually can: the data that is genuinely yours, the evaluation no one else will do for you, the specific human problem the frontier model does not care about. Own that, treat the model as the interchangeable part it is, and know, at every level, whose hands and whose engine you are standing on.