Turn-by-turn directions are fragile. Hand an agent a list of steps and one wrong step leaves it lost. A destination holds up better, because an agent that knows where it’s going can self-correct around a detour without you redrawing the route.

What a Destination Looks Like

There are three concrete forms a destination can take:

  1. An end-to-end user test with expected outcomes. Something the agent can check its own work against.
  2. Waypoints as sanity checks. Points along the way that tell the agent (and you) it’s still on the right road.
  3. Clear acceptance criteria and a definition of done. So the agent knows when to stop.

Each one describes the end state, which leaves the agent room to choose the route and to recover when the route it chose goes sideways.

The Leverage Test

The failure mode on the other side is chasing the agent’s output instead of directing it. The agent produces something, you read it to figure out what happened, it produces the next thing, and you read again. Every cycle is you reacting to the agent.

I think of this as a leverage test: if you are catching up to what Claude did, you’re capped at the speed of your own understanding, however fast the agent is.

The Decision Threshold

The hard problem is knowing which decisions Claude made on your behalf that you should have owned.

I picture the decisions as a pyramid. At the top are the user journey, the shape of the feature, and the functional outcomes. At the bottom are variable names and minor technical choices. I want to own everything above a threshold and nothing below it. The split is functional versus technical ownership: what should this do stays with the human, and how does it work can be delegated. That line isn’t fixed, either. The threshold moves up as the models improve, and more of the technical side can be handed over.

The pyramid says where the line should sit, but it doesn’t flag when the agent quietly made a call above it. What shows up instead is the symptom: “I don’t know what Claude built,” where you wanted “Claude built what I told it to build.”

Guardrails Are Rifling

CLAUDE.md rules, TDD, mutation testing, slash commands, a pre-PR review step: all of that is rifling. It improves the agent’s accuracy, and accuracy is useless without a target. The rules and review steps help the agent hit what it’s aiming at. They don’t decide what it should be aiming at.

That changes how I’d tune them. Don’t over-constrain the agent up front, and let the bad results show you where the gaps are. A few rules of thumb for finding and closing them:

  1. If CI fails three times in a row, that’s a sign the agent needs more context.
  2. Best-practice docs should live in the repo anyway, where the agent can find them.
  3. Anti-patterns you spot in PRs get fed back to the agent.

The other half of tuning is taking guardrails away. A rule that only existed to compensate for an older model’s weakness is noise once the weakness is gone, so each model release is a chance to delete the rules that are no longer needed. The constraints that are left should shrink over time while the destinations stay as clear as ever.