The one-paragraph ground rule to give AI before you delegate

A single paragraph, pasted at the start of any session where you hand AI something real, that installs a pause before the session starts and cuts the corrections you'd otherwise repeat every time.

AI defaults to completing the task. It doesn't pause when it hits something uncertain; it fills the gap and moves forward. Per OpenAI's guidance for AI agents, a model told to always act will invent the missing information rather than ask, unless you explicitly tell it to ask first. The workaround costs you thirty seconds at the top of any session.

What you'll have when you're done

A fill-in-the-blank paragraph you paste at the start of any AI session where you're delegating something that matters. It installs three things: what AI is not allowed to do, who the output is for, and when to stop and ask instead of guessing.

Five lines. The corrections you currently repeat mid-session happen a lot less often.

The problem this solves

The frustrating moment is when AI finishes confidently and it's wrong in ways that would have been obvious if it had just asked you first.

You hand it a draft to improve. It rewrites a section you didn't ask it to touch, inventing a statistic that sounds plausible. You ask it to prep a one-pager and it sends the tone in a direction that would land badly with that person, because it didn't know you've had friction there.

The model doesn't stop because nothing tells it to stop. It's a new EA who would rather hand you a finished draft than say "I wasn't sure about this part, should I check with you?" You can change that in one paragraph.

What you need first

• A Claude or ChatGPT account (the rule works the same on both).
• The task you're about to delegate. One real piece of work is your test case.
• Thirty seconds to paste the template and fill in the two brackets.

That's it. No setup, no technical background.

Step by step

Component 1: what it's not allowed to do

This is the guardrail. It defines the outer edge of what AI can do without your sign-off. Without it, the model acts as if everything is on the table, because for most people, it is.

An example line you can lift:

Do not send, post, share, or act on anything externally without showing me first and getting my explicit go-ahead. Do not invent facts, statistics, names, or quotes. If you do not know something, say so.

The irreversibility line matters most. Per OpenAI's guidance for AI agents, the trigger for a human check-in is irreversibility or external side effects: sending, deleting, posting. The model needs the explicit instruction; it won't infer it from general caution.

The "do not invent" line is the other load-bearing piece. AI will fabricate a statistic that looks right before it admits uncertainty. Naming it directly changes the behavior. For more on how to catch what does slip through, how to verify AI output covers the specific checks worth building into your review habit.

Component 2: what the output is for and who sees it

This is the calibrator. Without it, the model doesn't know if it's writing a board-ready document or a rough draft only you'll see, and it will guess.

An example line:

Everything you produce is a rough draft for my eyes only unless I say otherwise. Assume I will rewrite before anything leaves this document.

This line stops the model from over-polishing in directions you'll reverse anyway and anchors the output's assumed audience to you, not to a generic professional reader. Adjust it to match the actual situation: "input for a board deck I'll finalize," "talking points I'll rewrite for my voice," "a first pass my EA will review before it goes anywhere." The key is naming the real audience and purpose.

Component 3: when to stop and ask

This is the highest-leverage line in the paragraph. It's the instruction that converts confident-wrong into a question.

An example:

If you are unsure about a fact, if the task drifts outside what I asked, or if the next step needs a decision I have not made, stop and ask me rather than filling the gap yourself.

This handles the three situations where AI most often goes wrong silently: uncertain facts it invents, scope creep it doesn't flag, and decision points it fills in on your behalf. It isn't a general "be careful." It's a concrete rule with specific triggers. Give it the triggers and it will use them.

The complete fill-in-the-blank template

Copy this. Fill in the two brackets. Paste it at the top of any session where you're delegating something real.

You are helping me with [TASK TYPE: e.g. drafting emails / summarizing research / prepping talking points].
Do not send, post, share, or act on anything externally without showing me first and getting my explicit go-ahead.
Do not invent facts, statistics, names, or quotes. If you do not know something, say so.
Everything you produce is [AUDIENCE/PURPOSE: e.g. a rough draft only I will see / input for a board deck].
If you are unsure about a fact, if the task drifts outside what I asked, or if the next step needs a decision I have not made, stop and ask me rather than filling the gap yourself.

Every field does work. The task type calibrates the whole session from the start. The audience line calibrates the polish level. The escalation line is the one that changes the most about how the session goes.

Use it as-is the first time. You'll find one line that needs a word changed for your situation. Change it and save it.

How you'll know it's working

AI starts asking instead of guessing. You see more "I wasn't sure whether you meant X or Y, which is it?" and fewer confidently wrong outputs you have to undo. That trade feels slower at first. It isn't.

The first draft is closer. Less time rewinding from a direction the model assumed. The revision round is shorter because the session started briefed.

You stop repeating the same corrections. The template pre-empts the mistakes you were catching mid-session anyway, delivered once at the top instead of per-session.

When it breaks

You skipped the task type bracket. "You are helping me with [TASK TYPE]" still says [TASK TYPE]. Fill it in with the actual work. An incomplete template is like a briefing that trails off mid-sentence.

The escalation rule is too broad. "Ask me about anything uncertain" leads to approval fatigue. People quickly start rubber-stamping every prompt instead of reading them. The three specific triggers (uncertain fact, scope drift, unmade decision) are narrow enough to be meaningful. Broaden them and you'll get more interruptions without more value.

You're using it on tasks where the model doesn't need it. For low-stakes, fully reversible drafts, the rule is overkill. Use it when confident-wrong would cost you time, trust, or credibility. Skip it for quick brainstorms you'll throw away.

The output still drifts. If the model wanders outside the scope you named, that's usually a task type that was too broad. "Drafting emails" as a task type is narrow. "Helping me with communication" is open-ended enough that drift becomes likely. Name the work specifically.

Level up

The template works pasted fresh each session. The next step is making it automatic so you never skip it on the sessions where it matters most. Two ways:

Claude Projects. Drop the filled-in template into a Project's custom instructions. Every session inside that Project inherits it before you type your first word. The right move for any recurring task type: weekly prep, email drafting, research threads.

A standing-context file. If you're working in the terminal or in Claude Code, a standing-context file can carry the ground rule alongside your company context block. Every session in that file's scope starts with the rule already in place.

Either way, you write the template once and stop thinking about it. The briefing happens before the session starts.

One thing worth being clear on: this is a personal session rule, not a company AI policy. A company policy is org-wide governance involving HR, legal, and IT. This is your standing instruction to your own assistant, the equivalent of briefing a new EA before they start handling your inbox. For the org-wide governance piece, the AI usage policy template is where that work happens.

If you want to think harder about which tasks to delegate in the first place, when not to use AI covers the situations where even a well-briefed model is the wrong tool. The ground rule makes delegation safer. It doesn't decide what's worth delegating.

Paste the template into your next session this week. See what questions it surfaces that would have been confident wrong answers instead. That's the whole point.