There are two fundamentally different ways to work with an AI, and most people have settled into one of them without noticing there was a choice. The first is the centaur: you keep a clean seam between yourself and the machine, delegate whole sub-tasks across it, and integrate the results — human and AI as separate collaborators with an explicit division of labor. The second is the cyborg: you dissolve the seam and think in a tight loop, so it stops being obvious where your cognition ends and the model's begins. My claim is that which of these two modes a task calls for is a real decision with real consequences, that each has failure modes the other does not, and that the meta-skill of choosing correctly — then building the verification the chosen mode demands — is becoming the core competence of working with AI.
This is not a metaphor I invented. It has a precise history, and getting the history right is what makes the framework load-bearing rather than cute.
Where the centaur actually comes from
In 1997, IBM's Deep Blue beat Garry Kasparov, then the strongest chess player alive. The usual story ends there, with the machine's victory read as the moment human chess became obsolete. Kasparov drew the opposite lesson. In 1998 he helped launch "advanced chess" — later "freestyle" chess — where a human and a computer play as a single team. The human supplies judgment, long-range strategy, and knowledge of the opponent; the machine supplies brute-force calculation and blunder-checking. The name for such a team was a centaur.
The result that made the idea famous came from freestyle tournaments in the mid-2000s. The winners were not grandmasters with computers, and they were not the strongest engines running alone. They were relatively weak amateurs who had built excellent processes for combining themselves with several engines — knowing which engine to trust in which position, when to override it, when to let it calculate deep. Kasparov later distilled it into a formula worth memorizing: a weak human plus a machine plus a better process beat both a strong human plus a machine plus an inferior process, and a bare supercomputer. The scarce ingredient was never the calculation. It was the quality of the collaboration itself.
That is the centaur in its original form: a clean division of labor where the human does the part machines are bad at and hands off the part they are good at. It works in chess for a specific reason that matters enormously when we generalize — in chess, verification is cheap. You can check an engine's evaluation of a position quickly, and the seam between human strategy and machine tactics is clean and legible. The human always knows what was delegated and can inspect the result.
The cyborg is what happens when the seam dissolves
The centaur/cyborg distinction as a description of knowledge work comes from more recent field studies of professionals using large language models — most sharply from the 2023 Harvard/BCG experiment on management consultants using GPT-4, which documented a "jagged technological frontier" and named two distinct patterns among the people who used the tool well. Centaurs divided their work between self and machine along a clear line, allocating each sub-task to whichever was better suited. Cyborgs intertwined their effort with the AI's continuously, moving back and forth in a tight loop until the boundary blurred.
The difference is structural, not quantitative. It is not about how much you use the model; it is about where the seam sits. A centaur writing a report might have the AI draft an entire section from a spec, then read it, judge it, and slot it in — one clean handoff, one clean verification point. A cyborg writing the same report never hands off a whole anything. They type a half-sentence, the model completes it, they reject the completion but it shifted their thinking, they rewrite, they ask the model to argue the opposite, they steal one phrase from its answer and discard the rest. No discrete deliverable ever changes hands. The two produce similar artifacts through completely different cognitive architectures, and the architectures fail in different ways.
| Centaur | Cyborg | |
|---|---|---|
| Seam | Clean, inspectable | Blurred, continuous |
| Unit of work | Delegated sub-task | Interleaved micro-moves |
| Wins when | The task carves into verifiable chunks | The task is exploratory, generative, ill-defined |
| Verification | At the handoff, per chunk | Hard — provenance gets muddy |
| Signature failure | Under-using AI; carving at the wrong joints | Losing track of what you actually checked |
When each one wins, and how each one fails
The centaur wins wherever you can carve off a sub-task with a clear acceptance test — something where you will know quickly and cheaply whether the output is right. Convert this function to another language and run the existing test suite. Draft the boilerplate section of a contract against a known template. Generate forty headline variations so you can pick. The seam is clean because verification is cheap, the same property that made chess centaurs work. This connects to a real strand of labor economics: David Autor's task-based framing of automation, where a job is a bundle of tasks and technology substitutes for some while complementing others. The centaur is task-based thinking applied consciously — you decompose the job, hand the model the tasks it dominates, and keep the ones it doesn't.
The centaur's failure mode is under-use and mis-carving. Because delegation has overhead — specify the sub-task, wait, then verify and integrate — a timid centaur delegates too little and leaves the model's leverage on the table. A clumsy one carves the work at the wrong joints, splitting off a chunk whose correctness depends on context it never passed across the seam, so integration becomes a nightmare of reconciling a locally-plausible piece with a globally-wrong fit. The centaur is only as good as its decomposition.
The cyborg wins on exploratory, generative, ill-defined work — the stuff where the hard part is figuring out what you even want. Early-stage thinking, before you have a spec to delegate against. Writing that is really a search for the argument. Debugging a problem you can't yet name. Here the tight loop is the whole point: each exchange reshapes the question, and a clean handoff would be premature because there's nothing stable enough to hand off. Building Velya, our AI product, most of the genuinely hard product decisions started cyborg — I could not have written a spec for the model to execute, because the spec was the thing I was using the model to discover.
The cyborg's failure mode is the dangerous one, because it is quiet: you lose track of what you verified. When human and machine outputs interleave every few seconds, provenance dissolves. A number the model asserted in the third exchange gets carried forward as if you'd checked it. A framing it suggested becomes "your" position without ever passing through your judgment. The blurred seam that makes the cyborg powerful for exploration is exactly the surface through which unverified claims slip into finished work. The centaur always knows what was delegated; the cyborg often does not, and that is the tax you pay for the tight loop.
In both modes, the human's value is the same thing
Here is what does not change across the two modes, and it is the load-bearing point. In the centaur, the human value is knowing what to delegate and against what standard to accept it back. In the cyborg, the human value is knowing, moment to moment, which of the model's moves to keep and which to discard. Both are the same underlying function: judgment about quality that you can apply faster than you can justify. When execution gets cheap, the premium relocates to the seat that says this one, not those — the argument I've made at length in When Competence Is Free, Taste Is the Last Moat. The centaur and the cyborg are two delivery mechanisms for the same scarce good. One applies taste at clean checkpoints; the other applies it continuously. Neither generates the taste. You do.
Which is why the actual skill is not "be a centaur" or "be a cyborg." It is fluidly choosing the mode a task needs, and switching mid-task when the task changes under you. Most real work is a sequence: cyborg to find the shape of the thing, then centaur to execute the pieces once the shape is clear and the sub-tasks have become specifiable and verifiable. The people who are visibly better at working with AI right now are, almost always, the ones who make this switch without thinking about it — who feel when a problem has crystallized enough to delegate, and when a delegation has hit something ambiguous enough that they need to drop back into the loop.
The honest counterargument, and where this is heading
The strongest objection is that the distinction is transitional. As models get more autonomous and handle longer task horizons, maybe everything drifts toward pure delegation — the cyborg loop collapses because you can hand over the whole job, and the centaur becomes the only mode, which is to say the human becomes a manager. There's real truth here, and it points at where the work is going: I've argued that Everyone Becomes a Manager (of Agents), and the centaur is precisely what management scales into — decomposition, delegation, verification at the seam, done over and over.
But delegation does not erase the cyborg; it relocates it. The frontier of what you can cleanly specify is always moving, and at that frontier — deciding what you actually want, what the real constraints are, what "good" means for this particular thing — there is nothing yet to delegate, so you think in a loop with the model. Cyborg work concentrates at the edge of the specifiable, and that edge does not close. It moves.
There is a second risk that cuts inward, and it's the one I'd watch most carefully. Working cyborg-style all day can erode the very judgment the whole framework depends on. Learning science on desirable difficulties, associated with Robert Bjork, holds that skill is built through productive struggle — the effortful retrieval and problem-solving that a tight AI loop is superb at removing. It's the same worry that sits behind Bloom's two-sigma finding on tutoring: the gap between a mediocre and an excellent learning process is enormous, and a frictionless one can be a great performance aid while being a terrible teacher. Offload every near-miss decision to a decent-but-not-great model and your taste drifts toward the model's mean and stops improving. The centaur has some natural protection here, because the handoff forces you to specify and to judge; the cyborg's frictionlessness is exactly what makes it a risk to the judgment it runs on. The defense is deliberate: keep some reps where you commit to a verdict before you see the model's, and treat those as training rather than production.
So the practice reduces to something you can do on the next task in front of you. Before you start, decide consciously: is this a centaur task or a cyborg task? Can I carve a verifiable sub-task, or is the hard part figuring out what I want? Then build the verification that mode needs — checkpoints at the seams for the centaur, a provenance log of what you've actually checked for the cyborg. Pick the mode on purpose, or the task will pick one for you, and it will usually pick wrong.
The centaur and the cyborg are not two kinds of people. They are two tools on your belt, and the professional skill is no longer knowing how to swing one — it is knowing, without being told, which one the moment in front of you requires.