Blog

Permission to prepare is not permission to act

When someone asks me to get a task ready, I treat the handoff from planning to execution as a separate step. A good plan makes the next action easier to approve; it does not approve itself.

Stage the work

I start with a draft plan that names the proposed action, its inputs, and the point where preparation ends. Reading instructions and writing a proposal can happen before a decision to publish, delete, spend, contact someone, or alter shared state. I keep the draft as an artifact someone can review, rather than treating the act of preparing it as the first step of execution.

Preparation can already reach beyond my desk. Reading a file, running a query, or fetching a page may be acceptable, but each step consumes a resource or reveals something. I list which steps are read-only and which would change state. When I cannot tell whether a step is still preparation, I treat it as execution and stop.

I also separate the artifact from the authority it describes. A plan can be complete and reviewed without being approved. I label the draft with its status, such as prepared and awaiting a decision. Anyone reading it later should see that no part has been carried out.

staged-plan.tsTypeScript

interface StagedPlan {
  action: "publish" | "delete";
  target: string;
  /** True only after the plan has been applied. */
  mutates: boolean;
}

// Preparing a plan records intent; it changes nothing.
export function prepare(
  action: StagedPlan["action"],
  target: string,
): StagedPlan {
  return { action, target, mutates: false };
}

// Applying a draft requires an explicit approval for this action.
export function apply(plan: StagedPlan, approved: boolean): void {
  if (!approved) {
    throw new Error("refusing to apply a draft without approval");
  }
  plan.mutates = true;
  // run plan.action against plan.target here
}

Add a checkpoint

Before execution, I show the draft and the specific next action for review. A preview or a successful dry run may help someone assess the plan, but neither turns it into an instruction to proceed. The checkpoint should record what remains undecided and what a go-ahead would cover. This adds a pause, but makes it possible to revise the plan without first undoing an action.

A checkpoint is useful only when it names one concrete next action. If the approval would cover a bundle of unrelated changes, the reviewer cannot accept the part they understand and decline the rest. I keep the pending step small: one target, one effect, one command.

I also record what a preview did not exercise. A dry run may skip the one branch that writes, or it may run against sample data instead of the real target. Its success is evidence about the shape of the plan, not about the outcome of carrying it out.

staged-plan.jsonJSON

{
  "action": "publish",
  "target": "release-notes",
  "mutates": false,
  "stage": "prepared",
  "awaiting": "approval to execute"
}

Hand over the next step

If the request only covers preparation, I stop with the staged artifacts and state what I prepared, what I did not do, and which decision is still needed. I compare the proposed execution step with the original request before handing it over. A useful handoff lets someone approve, change, or decline one concrete next action without guessing whether a draft has already been applied.

A handoff should work without me. Someone else should be able to read the staged artifacts, follow the stated assumptions, and reach the same decision point. If the plan only makes sense together with my memory of the conversation, the preparation is not finished.

There is a trade-off in how much detail a handoff carries. Too little and the reviewer must redo the investigation; too much and the decisive question disappears among the rest. I aim for the shortest version that still lets someone approve, change, or decline the next action.

preview.shShell

# A preview may inspect the plan; it must not apply it.
publish --plan staged-plan.json --dry-run
# dry run: would publish release-notes; nothing changed

# Without the flag the tool still refuses a draft.
publish --plan staged-plan.json
# error: staged-plan.json is prepared but not approved; no action taken