Turn One Task Into a Reusable AI Prompt

Start here

What to paste: one message containing this prompt text plus your own answers in the five [INPUT] slots — your repetitive task, what stays the same each time, what changes each time, one real past run (raw input and finished output), and your quality requirements and hard boundaries.

Where to paste it: the text box of an ordinary AI chat that accepts text. No terminal, account connection, API key or setup step is involved.

How to check the output: confirm you get all six parts in order, that the one-placeholder slot is a single marked line, that the walkthrough is labelled as a fictional-style example, and that anything you left blank is listed as UNRESOLVED instead of filled in.

What this does

A recurring task — a weekly summary, a standard reply, a short report — is usually re-explained from scratch every time. This prompt converts one such task into a compact instruction block you can paste into any capable AI assistant whenever the task comes round again. It also runs your instruction block once on a real past run so you can see the shape of the result, and it lists gaps and rule conflicts before you rely on it.

It is a drafting and self-check exercise. It produces text you copy and use yourself.

Prerequisites and permissions

There is nothing to install and nothing to connect. You supply text; you receive text. The prompt cannot access an account, file, calendar, mailbox or external service, and nothing it writes sends, schedules or saves anything. Keep the last field for anything sensitive that must not be reproduced.

Working through the inputs

A weak past run is not fatal. Say it is thin, and the block is written to still produce a usable draft while flagging the weak spots rather than papering over them.

How to read the result

The answer arrives in six parts: the instruction block, the single variable slot, a walkthrough, a self-check, a reuse checklist, and up to three fixes. The walkthrough carries the label FICTIONAL-EXAMPLE-STYLE WALKTHROUGH — NOT A LIVE RUN, and it is a shape demonstration only. The self-check marks invented additions as SPECULATIVE and states conflicts instead of quietly choosing a side.

Source reviewed; runtime not tested.

FAQ

Does this connect to my calendar, files or mailbox? No. It only writes text back to you, and you paste the instruction block wherever you like yourself.

What if I only have a rough idea of the task? Give the rough version. The answer should list what is missing and what the smallest useful version of each missing piece looks like, then continue with only what you gave, marking the rest UNRESOLVED.

Complete reusable prompt

You are helping me turn one repetitive task into a reusable instruction block I can paste into an AI assistant whenever I need it again. This is a drafting and self-check exercise: you produce text I will copy and use later myself. You cannot access any account, file, calendar, mailbox, or external service, and nothing you write here performs an action, sends anything, or saves anything automatically.

My repetitive task (name and short description, plus frequency and who the output is for): [INPUT]

What I already have that stays the same each time (templates, formats, lists, terminology, style rules, house conventions): [INPUT]

What changes each time I run it (the variable part I will paste in — e.g. raw notes, a new request, a new document section, a set of data): [INPUT]

One real past run of this task, as I actually did it — raw input and my finished output, even if messy or imperfect: [INPUT]

My quality requirements and hard boundaries (things the output must never do, include, or assume; anything sensitive that must not be reproduced): [INPUT]

If any section above is empty or too vague to work from, do not invent the missing details. Instead, list what is missing and what the smallest useful version of it would look like, then continue with only what I gave. Mark anything you could not produce for that reason as UNRESOLVED rather than filling it in.

Produce the following, in this order.

1. INSTRUCTION BLOCK — the reusable part Write a single, self-contained block of instructions that could be copied into any capable AI assistant. It must:

• State the task and the role the assistant should take.
• Define exactly what input the assistant will receive each run, and what it should do if that input is empty, incomplete, or off-topic.
• Specify the exact output format: sections, order, length guidance, tone, and what to do when a required piece of information is absent (leave a clearly labelled gap rather than guessing).
• Carry over every constant from my 'stays the same' list and never contradict my quality requirements or hard boundaries.
• Avoid any claim of tool access, browsing, sending, scheduling, or memory. Phrase everything as instructions for what the assistant should write, not actions it should take.
• Be written as instructions to the assistant, not as instructions to me.

2. ONE-PLACEHOLDER VARIABLE SLOT Show, as a clearly marked line, the single slot where I paste my changing input each time, and describe in one sentence what belongs in it.

3. WORKED EXAMPLE Run the instruction block once on the real past input I supplied. Show:

• A short label line: 'FICTIONAL-EXAMPLE-STYLE WALKTHROUGH — NOT A LIVE RUN.'
• The raw input used, quoted from mine, or a minimized version if it is too long.
• The output the block produces, in full, following your own format rules. This is a worked example showing the shape of the result, not evidence that anything ran live.

4. SELF-CHECK AGAINST MY MATERIALS Go through the worked example and report:

• Which parts are directly supported by what I supplied.
• Which parts are gaps, assumptions, or plausible-sounding additions I never provided. List each one as SPECULATIVE and either remove it or mark it.
• Any place where the block's own rules and my quality requirements conflict, or where two requirements cannot both be satisfied. State the conflict instead of silently picking a side.
• Any hard boundary that the worked example brushes against.

5. REUSE CHECK State in one list what a future run must verify before I trust the output: input completeness, format compliance, unsupported claims, boundary compliance, and anything task-specific I insisted on. Keep each check short enough to actually perform.

6. WHAT TO FIX BEFORE I REUSE THIS Give at most three concrete edits to the instruction block that would most reduce rework, based on the gaps and conflicts you found. If there is nothing meaningful to fix, say so instead of inventing improvements.

Rules for your whole answer:

• Do not add facts, deadlines, names, numbers, policies, or sources that are not in my input.
• Do not restate my hard boundaries as optional.
• Do not use phrases suggesting you accessed, changed, sent, or stored anything.
• Keep the instruction block compact enough to paste into a chat window in one go.
• If my past run is weak or incomplete, say what is weak and write the block so it will still produce a usable draft, flagging the weak spots rather than papering over them.

Labelled fictional mini example (style only, not real data): Input: recurring task = 'weekly summary of client call notes'; constants = plain tone, three bullets max, no client names; variable = this week's raw notes; past run = messy notes with two action items; boundaries = never invent deadlines. Expected output shape: an instruction block, one 'PASTE HERE' slot, a walkthrough summary with two bullets and a flagged missing deadline, a SPECULATIVE list for any invented owner, and a short reuse checklist. Pass/fail checks: fail if the block claims it can send or file anything; fail if the walkthrough invents a deadline or owner not in the notes; fail if the constants are dropped; pass only if gaps are labelled and each check can be tied to the supplied inputs.

References and reuse

• Let skills in Gemini tackle your most repetitive tasks · Wed, 30 Sep 2026 16:00:00 +0000

Original TokRepo prompt · CC BY 4.0. Reference documents retain their own rights.