The Harness

Our long-form take

Expanded Essays on the Three Gaps

Three core theses on harness design: how it changes the human, why design is editorial taste, and why the harness itself may be transitional.

00 — The Seat

Before the Saddle, You Were Gripping

This essay is about what sitting on a saddle does to a person. Not to the horse — to the rider. Before the saddle, riding meant survival. You were clamped to the horse's back, every muscle braced against falling. The horse had the power. You were managing the relationship, not directing it. The saddle changed that — not by making the horse stronger, but by giving the rider a seat. Spine straightens. Gaze lifts. Hands free. The body stops managing and starts directing. The transformation isn't in the horse. It's in the rider.

01 — The Shift

The Harness Gives You a Seat

A developer without a harness is gripping. Syntax. Boilerplate. API signatures. Context-switching between writing and looking things up. Holding the entire implementation in working memory, terrified of losing the thread. The work is exhausting not because the problem is hard but because the cognitive overhead of execution crowds out the cognitive space needed for thinking.

The harness gives you a seat. You stop gripping implementation detail and start directing intent. Your attention rises — not to the line, but to the system. Not how do I write this but what should this do. Same posture shift as the saddle. Same hands-free moment.

02 — Altitude

What Changes When You're Not Gripping

When you're not spending mental energy on staying on, you have capacity for navigation. The harness changes your operating altitude. Tasks that used to be "too big to hold in your head" become tractable — because the harness holds the details. You think in systems instead of functions. You start attempting things you'd previously self-censor because the implementation cost alone felt prohibitive.

This isn't just speed. Speed means the same work, faster. This is different work — work you wouldn't have attempted at all. A solo developer with Claude Code will scope a project that used to require a team. Not because they got smarter. Because they got a seat.

03 — Identity

You Don't Go Back

A rider who's used stirrups for years thinks differently even off the horse — about distance, terrain, what's crossable. The stirrup doesn't just change how you ride. It changes how you see landscape. The harness does this too. A developer who's worked with Claude Code for a year starts to see problems differently. Not can I implement this but should this exist. Not how long will this take but what's the right shape of this.

The implementation question fades. The judgment question sharpens. You've stopped thinking of yourself as someone who writes code and started thinking of yourself as someone who directs systems. That's not a workflow change. It's an identity shift. And like most identity shifts, you don't notice it while it's happening.

04 — The Risk

The Saddle Made You Dependent on the Horse

The stirrup gave cavalry its power — and made cavalry absolutely dependent on horses. Dismounted, the knight was slow, exhausted, nearly useless. The harness specializes you. Skills you stop using atrophy. Bareback riding becomes uncomfortable, then impossible.

A developer who's worked in a harness long enough may find direct, unassisted coding genuinely hard — reading raw docs, writing boilerplate from memory, holding a large codebase in working memory without help. This isn't laziness. It's specialization. The generation that grew up with GPS cannot read maps. That might be fine. It might not be. The harness reshapes the rider. What it reshapes toward is a choice you're making whether you recognize it or not.

Claude Code and Cursor use the same model. They feel completely different. Not because of a technical difference you can point to in an architecture diagram — because of a thousand small decisions about what to show, what to hide, when to ask, when to act. These are aesthetic choices. Harness design is closer to product design than to systems engineering, and the industry hasn't reckoned with that. The best harnesses won't be built by the best engineers. They'll be built by the best editors — people who know what to leave out.

Every piece of writing about harnesses treats them as a permanent architectural layer. But the endgame is obvious: the model builds its own harness. Today, Claude Code can't configure its own tools or modify its own system prompt. Tomorrow's models will scaffold their own environments, choose their own tools, and set their own safety boundaries. The harness is a transitional technology — training wheels for a thing that will eventually ride on its own. The interesting question isn't how to build the best harness. It's what happens when the model no longer needs one.

You described the key distinction clearly: Claude Code feels like precise architecture, while Codex feels like abstract painting. We turned that into a complete interactive essay page with modules for thesis building, identity reflection, risk analysis, and a full draft.

Open the page: Force and Steering Essay Workspace.

00 — The Analogy

No One Rides Bareback

A horse is a thousand pounds of speed and power. Humans figured that out ten thousand years ago. But the horse wasn't the breakthrough. The saddle was.

Before the saddle, you could ride — badly, briefly, and at the mercy of the animal beneath you. The saddle gave you a seat. The stirrups gave you leverage. The reins gave you direction. Suddenly the most powerful thing on four legs was yours to direct. Not tamed. Not diminished. Connected.

We're at the same moment with AI. The model is the horse — fast, powerful, astonishing. It can write code, synthesize research, debug distributed systems — and yet, out of the box, it can't read a file. A brain in a jar. Raw capability isn't the bottleneck. The connection is. The software that wraps a model, gives it tools, points it at your work, and lets you steer — that's the saddle. We call it a harness.

01 — The Concept

Enter the Harness

A harness is the software that wraps around a model and connects it to the world. It transforms raw intelligence into useful agency — giving the model hands, eyes, and memory.

The word carries exactly the right connotations. A harness is structural — engineered for a purpose, not bolted on as an afterthought. Connective — it links the powerful thing to the useful thing. Directional — it channels energy toward a goal. And respectful — it doesn't diminish what it wraps. A harness doesn't make a horse smaller. It makes the horse's power available.

Claude Code is a harness. Cursor is a harness. Codex is a harness. Every system that takes a model and makes it do real work is a harness. The question isn't whether you're using one — you always are. The question is whether it's a good one.

02 — Anatomy

What a Harness Provides

When you use Claude Code, you're not talking to Opus. You're talking to Opus through a harness — one that provides a specific set of capabilities. Take them apart:

What the harness gives the model

Perception    Read files. Glob for patterns. Grep for content.
              See the codebase as it actually is right now.

Action       Write files. Edit code. Run shell commands.
              Make changes that persist in the real world.

Context      CLAUDE.md files. Git status. Conversation history.
              Know where it is and what matters here.

Memory       Project notes. User preferences. Past decisions.
              Build on previous work instead of starting fresh.

Judgment     Permission systems. Safety rails. Confirmation prompts.
              Know when to act and when to ask.

Feedback     Test results. Linter output. Build errors.
              See the consequences of its own actions.

None of this is the model. The model doesn't "have" tools — it's given tools by the harness. The model doesn't "remember" your project — the harness loads context into the conversation. The model doesn't "decide" to be careful with destructive commands — the harness enforces permission boundaries.

The model provides the reasoning. The harness provides everything else.

03 — The Distinction

Not Just an App

There's an obvious objection: isn't a harness just an app? A wrapper? A thin layer of UI over an API? No. An app presents information and takes input. A harness manages a loop — perception, reasoning, action, feedback — and keeps it running autonomously. The architecture is fundamentally different. A chat interface is a harness, technically. It's just a bad one — it gives the model no eyes, no hands, and no memory. You become the hands, copying files in and pasting diffs back.

This is the default experience most people have with AI today, and it's why so many walk away underwhelmed. The model is powerful. The harness is anemic. A copy-paste workflow forces the human to be the perception layer, the action layer, and the feedback loop — all at once. The model sits in the middle, brilliant and helpless.

And the pattern extends far beyond coding. NotebookLM is a research harness — it ingests your sources, lets the model read across them, and generates synthesis you couldn't get from a chat window. Perplexity is a search harness — it gives the model live access to the web and the ability to reason over results. Devin, Replit Agent, v0 — all harnesses, each connecting the same underlying intelligence to a different domain. The concept isn't specific to code. It's wherever a model needs to touch the world.

04 — The Evidence

Three Harnesses, One Pattern

If "harness" names a real architectural pattern, you should be able to find it in the wild — independently reinvented by teams with different goals and different constraints. You can.

Claude Code is Anthropic's proprietary CLI, tightly integrated with Claude models. OpenCode is an open-source terminal agent, model-agnostic, supporting 75+ providers. Codex is OpenAI's cloud-native coding agent, sandboxed and async. Different companies. Different constraints. Different philosophies.

Line them up and the anatomy is identical. Same capabilities, same architectural layers, same separation between harness and engine. This isn't copying — it's convergent design. The problem constrains the solution.

05 — Closing

Now You Can See It

Once you have the word, you start seeing the pattern everywhere. Every time a model reads a file, runs a command, or remembers a preference — that's the harness at work. Every time it can't — that's the harness missing.

The concept isn't new. People have been building this layer since the first developer plugged GPT into a script. What's new is the name — and with it, the ability to see the architecture clearly: model here, harness there, and between them, all the decisions that determine whether raw intelligence actually reaches the work.

A horse is fast. A saddle makes it yours. A model is brilliant. A harness makes it useful. That's the whole idea.