In 1895 you didn’t buy a car. You bought a horseless carriage — the new machine named for the animal it removed. The name is the whole lesson: the carriage didn’t change. The wheels, the seats, the cab — all still there. What changed was what pulled it. The horse went out, the engine went in, and the same carriage could suddenly run at a pace no stable could feed.

Here is the same swap, happening right now, in software.

Copilot is the carriage. It’s the vehicle everyone already has — the chat surface, the agents, the buttons, the place work actually rides. It is a genuinely good carriage.

You are the horse. Today, almost everything a copilot does, it does because a person is pulling: typing the prompt, clicking the button, checking the output, deciding what happens next, then pulling again. Call this configuration what it is — You + Copilot, a personed harness. It works exactly the way a horsed carriage worked: beautifully, at the pace of one animal’s attention, and it stops the moment the animal needs to sleep, eat, or attend a meeting.

The Brainstem is the engine. A brainstem — in my RAPP work that’s the literal name — is a persistent engine built out of your stuff: the agents you’ve written, the tools you’ve wired up, the memory of how you do things. It isn’t a smarter chat window. It’s the thing that can sit where you sit and pull what you pull. Put it in front of the same carriage — Brainstem + Copilot — and you have a personless harness: the carriage unchanged, the pulling replaced.

What the swap looks like in practice

This is not a story about testing. It’s a story about the new way of work — testing just happens to be the first seat the engine took from me, because testing is the purest form of person-as-horse: a human clicking through an app after every change to see what broke.

I had just finished a feature I believed was done. Instead of strapping myself into the harness — open the app, click the toggle, watch the panel, check the download — I handed the job to an agent with a real browser and a list of expectations, and went to work on something else.

It came back with five defects. One was a blocker: the page was loading with zero JavaScript, so the whole feature was a painting of itself. Another: the one control that half-worked was a switch that could be turned on but never off. A third: a checkbox had quietly stretched to 87 pixels wide and shoved its own label onto three lines. Nothing in my automated test suite could see any of this, because it all lived in the seam between “the code is right” and “the thing works when a hand touches it.” It was findable only by pulling the carriage — which until that day had meant me.

I fixed the five, sent the engine back in, and it returned a green table: thirty-three checks, no human involved. My report changed from “try it and tell me what breaks” to “it’s done, and here’s the run that proves it.”

What makes an engine trustworthy in the harness

A few things separate an engine you can trust from a demo that waves its hands:

  1. It pulls through the front door. Real clicks, real dialogs, real downloads — not API calls impersonating a user. The whole value of the person it replaced was that they used the product like a person.
  2. It expects the annoying things. A confirmation popup it didn’t predict is a failure, not a nuisance. Layout gets measured — “this control is at most 22 pixels” — not eyeballed.
  3. It checks what should be absent. The feature that must stay invisible until enabled, the panel that must vanish on disable. Human testers almost never verify that things are properly gone. An engine always can.
  4. It never fakes a pull. If it can’t run, it says so loudly. A green light that didn’t actually execute is worse than a red one.

The arithmetic: horsepower over personpower

James Watt invented the unit “horsepower” for a simple commercial reason: he was selling engines to people who owned horses, so he measured what a horse could sustain and priced his machine in the buyer’s own units. Let’s do the same. Define one personpower as one attentive power user at a browser — someone who knows the app, knows the checklist, and doesn’t dawdle.

My harness run is 33 checks across two surfaces. Hand-executed, the mix is unforgiving even for a fast operator: the simple look-and-click checks go at ten seconds or so, but verifying a prefilled URL’s query parameters takes half a minute, measuring whether a control is 13 pixels or 87 takes a trip into devtools, and confirming an exported file actually downloaded and contains what it should takes a minute of its own. Averaged across the mix, that’s a solid twenty minutes per full pass — and you have to do the pass again after every fix.

The engine’s measured time for the same 33 checks: 19.1 seconds. That’s roughly a 60:1 ratio on the stopwatch — the engine runs at about sixty personpower on this workload. But the stopwatch undersells it, because the honest denominator is attention: the twenty human minutes were twenty minutes of a person’s full focus, while the engine’s nineteen seconds cost zero. I ran it four times tonight without noticing.

The carriage stays; the horse retires

Notice what the swap does not ask of you. You don’t abandon the carriage. Copilot, the app, the surfaces you’ve already invested in — all of it stays. That’s why the horseless carriage won so fast: it didn’t ask the world to reinvent the wheel, only to stop feeding the horse.

And notice where the person goes. Ford’s engine didn’t remove people from travel; it moved them from pulling to steering. The Brainstem doesn’t remove you from the work; it moves you to the seat where you set the destination and read the verdict. You stop being the horse. You were never at your best as the horse.

“Horseless carriage” survived only as long as it took people to forget that carriages had ever needed horses. “Personless harness” will go the same way. For a while it will be the odd new practice with the odd new name — and then it will not be “the new way of testing” or even “the new way of automation.” It will just be work: Brainstem + Copilot, the engine pulling and the person steering. And the idea that a human being once hand-pulled every prompt, click, and check through their copilot will sound like keeping a horse for your commute.