🏎️ Harness fundamentals

Everything involving the model: prompts, skills, environment, and codebase.

It’s where the lever you actually control is.

Engine = model; car = harness; almost total control.

The engine is one part; the chassis and aerodynamics make the car win.

Shifts your focus from the shiny toy to the system.

System > component; chassis mindset.

Prompts, environment, and codebase are 100% in your hands.

Changes where it's worth investing time: in what you change today.

Three levers; improvement independent of the model.

The obsession with the new model and the vibe coder who switches every week.

Keeps you from getting stuck on one model and never learning the fundamentals.

Think through the harness, not the model.

Pocock gives equal weight to the model and the harness.

Half the result is under your direct control.

50/50 balance; the harness makes the model cheaper.

Translate “improve the AI” into “improve the harness.”

Greatest return per hour invested.

Checklist: prompt, skills, environment, codebase.

The idea behind ML (Rich Sutton): raw compute beats hand-crafted optimizations.

Explains why betting against the progress of models tends to lose.

Compute scales fast; general methods > manual tricks.

The idea of just waiting for the model to improve—“waiting for the engine to get better.”

It’s the mirrored mistake: outsourcing all your progress to the lab.

Waiting around ≠ a strategy.

Even with the Bitter Lesson, there’s still a lot to gain by optimizing the harness today.

The limit of the lesson: it doesn’t tell you to do nothing.

Compute is increasing; the harness still multiplies results now.

“Waiting around for AGI without doing anything was a really dumb idea.”

Action compounds: every harness improvement earns interest as the model evolves.

Act now > wait; improvements compound.

Middle ground: improve the whole setup every day AND use the best model.

Avoids both extremes: over-optimizing the harness or just waiting for the engine.

“I do the best I can with what I have now.”

Invest in the harness now; use the best model; don't bet everything on waiting.

Turns theory into a weekly routine.

Routine: 1 harness improvement per week + best model.

Keep the workspace/harness as model-independent as possible.

What’s agnostic survives the next model swap.

Agnosticism = resilience to change.

“If I over-optimize around one model, I lose focus on the fundamentals.”

Coupling yourself to a model creates debt when it changes.

Over-optimization = future debt.

Focus on what has worked for 30-40 years; it tends to keep working.

Old fundamentals are the safest long-term bet.

Timeless best practices > shiny novelty.

Jump from tool to tool without learning any principles.

It’s the opposite of agnosticism: lots of novelty, zero foundation.

Changing everything ≠ improving.

Apply sound fundamentals to survive model changes.

A hardened setup costs less with every model release.

Portable patterns; loose coupling.

How to audit whether you’re locked into a model.

Makes agnosticism verifiable, not vague.

Objective checklist.

The agent’s experience working in your codebase.

Good AX makes the agent more effective and cheaper.

AX = the agent's environment.

DX and AX overlap substantially; good DX already improves AX.

You don't have to choose: improving one improves the other.

A good senior who delivers good DX already delivers AX.

What helps the agent explore without running into trouble.

Guardrails reduce trial and error and costs.

Clear boundaries + obvious paths.

“Enough documentation to point AI to the right places.”

Too many docs become noise; the right doc speeds up the agent.

Concise, directional docs.

Improving the codebase means improving the environment the model runs in.

It’s the most overlooked — and one of the most powerful — AX levers.

Codebase = environment; environment = AX.

Signs of a codebase with good AX.

What you measure, you improve.

Observable signs of AX.

“How do you optimize token spending? Make your codebase easier to change.”

Architecture is the most underestimated cost lever.

Easy to change = cheap to operate.

Better guardrails → the model spends fewer tokens struggling.

Every avoided clarification saves tokens.

Guardrails = less trial and error.

Better codebase → a cheaper/simpler model does the same work.

It’s like paying less for API without losing results.

A good harness lowers the model you need.

“Handcuffing the model from day 1” forces you to use an expensive model.

The cost shows up as a dependency on an expensive model.

Bad codebase = permanent tax.

Refactoring to make changes easier is cost optimization.

Each refactor reduces the tokens spent on future changes.

Refactor = lower marginal cost.

How to think about cost per change.

It gives you a number to guide refactoring.

Tokens/change as a compass.

Every skill leaks its description into the context window.

Context is finite; every leak takes up space.

Skill description = context cost.

100 skills = 100 descriptions leaking into the context.

The “skills list” isn’t free.

More skills = more leakage.

`disable model invocation: true` → skill only invoked by you, without leaking its description.

Lets you have the skill without paying its context cost.

User-only procedure; hidden description.

“Everyone stuffs the context window with too much stuff, too many instructions.”

Too many instructions hurt performance; they don’t improve it.

Less is more in the context.

Go back to the blank slate and observe the pure agent.

That's the only way to see what you really need to add back.

Delete everything → observe → remap.

Cut what adds no value; keep knowledge with the human.

Clean context improves performance and lowers cost.

Ongoing context hygiene.