Pick your posture before you pick your prompt
A question I get asked more than any other about running an agentic coding harness day to day: how careful should the agent be? The honest answer is “it depends,” which is unsatisfying but true, and the more useful thing I can offer is what it depends on. It depends on whether the work is reversible, whether anyone else’s time is on the line, and whether a mistake costs you an hour of cleanup or costs someone else a broken production system. Those are wildly different situations, and trying to write one prompt that behaves correctly in all of them is a losing effort.
Early on I tried to solve this with a single set of instructions tuned to a sensible middle ground: careful enough not to break a shared repository, fast enough not to be unbearable on a personal project. It was wrong in both directions simultaneously. On my own throwaway projects, the agent asked for confirmation before changes that cost nothing to undo, stopping to check in on decisions I’d have made instantly myself. On shared, ticket-backed work, the same middle-ground instructions let it move faster than the situation warranted — skipping review steps that existed for a reason, because the default posture had been calibrated for solo work rather than for a shared repo where an unreviewed mistake affects someone else.
The fix was to stop pretending there’s one right level of ceremony and instead make the posture an explicit, named choice made before any work starts. In practice this means defining at least two operating modes and requiring one to be selected — implicitly by context, explicitly by invocation — before the agent does anything. A fast, autonomous posture for personal, low-stakes, individually-owned work: default to action over asking, pick a sensible option instead of presenting a menu, accept that some things will need to be redone because the recovery cost is low and the repo is fully under your own control. And a slower, higher-ceremony posture for shared or ticket-backed work: explicit checkpoints, a documented plan before implementation, an adversarial review pass before anything is considered finished, because the recovery cost is higher and other people’s assumptions are riding on the result being right the first time.
The reason this beats a single calibrated-for-everything prompt is that the two postures aren’t points on the same dial — they’re different value functions. In the fast posture, the thing being optimized is throughput: get real work done across as many iterations as possible, and treat an occasional wrong turn as cheap because it’s on a branch nobody else depends on and git makes it reversible. In the careful posture, the thing being optimized is confidence: make sure that when this ships, it’s actually correct, because the cost of finding out it wasn’t is now paid by someone else, later, in a context where it’s harder to trace back to the decision that caused it. A prompt tuned to split the difference optimizes for neither. It’s cautious in exactly the situations where caution is waste, and casual in exactly the situations where casualness is risk.
Making the mode explicit also solves a coordination problem that a single implicit posture can’t: it gives both the human and the agent a shared, nameable thing to reason about instead of an ambient vibe. “This is personal-mode work” and “this is delivery-mode work” are statements either party can make and the other can act on immediately, the same way “this is a hotfix” versus “this is a feature” changes how a human engineering team behaves without needing a paragraph of justification each time. Without a name for the posture, every task starts by re-deriving how careful to be from scratch — and re-derivation under uncertainty tends to regress toward whatever the most recent task trained the agent to expect, which is exactly the kind of implicit drift that then shows up as either excess caution or excess risk in the next unrelated task.
The other design choice worth calling out is that the mode should be sticky within a task but not sticky across tasks. Once you’re in the careful posture for a piece of shared work, staying in it for the duration — rather than quietly reverting to the fast default the moment the agent hits something tedious — is what makes the guarantee meaningful. But the posture shouldn’t leak into the next unrelated task by default either; a harness that remembers “we were being careful last time” and applies that indefinitely ends up back at the single-calibration problem, just shifted toward the cautious end. The invocation, not the history, should decide the mode each time, with the ambient default falling back to whichever posture matches the surrounding context — a personal repository defaults to the fast posture, a ticket in a shared tracker defaults to the careful one — and an explicit override always winning over the default.
None of this requires a sophisticated mechanism. It requires naming the postures, writing down what changes between them — approval gates, review depth, tolerance for breakage — and being disciplined about picking one before work starts rather than discovering the right level of caution in hindsight, after the wrong one already shipped. The dial doesn’t need to be finer than two settings for most of what a coding harness actually does. It just needs to actually be a dial, chosen deliberately, instead of a single fixed setting pretending to serve every situation equally.