Turn a goal into a reusable prompt, with its variables and a test plan
A prompt generator for ChatGPT or Claude. Give it the job you want done and it returns a reusable prompt, its variables, three test inputs and its failure mode.
- Works in
- Claude
- You need
- The job you want done · Who the output is for · What a good answer looks like
- Written for
- chatgpt prompt generator
Scored by our own engine
This page, run through the audit we sell. Measured 11 August 2026.
Most prompts fail for one of two reasons. They name a subject instead of a deliverable, or they leave the output format to the model. This prompt takes a description of a job and returns a working prompt, its variables, three test inputs and the one way it is likely to break.
Why the output has five sections and not one
A generator that returns only a prompt hands you something you cannot evaluate. You run it, you get a plausible answer, and you have no way to tell whether it is right or merely well formatted.
The other four sections exist to make it checkable. The variable table tells you what a vague input will do to the result. The test inputs give you a pass condition before you have any real data at stake. The failure mode names the thing to watch for. And the last section, what was deliberately left out, is the one that catches the request that could not be satisfied honestly, usually because it asked the model for something it cannot know.
The test that people skip
Test three is the one worth running. It is an input where the correct response is to say the answer is not in what you gave me.
Assistants answer that input anyway, fluently, unless the prompt tells them not to. We watched exactly this in a controlled run of a research prompt with web access turned off: one assistant declined and said it could not verify anything, and another produced a complete report with a tidy citation list in which one of the URLs was a hard 404. The output looked better than the honest one. That is the failure to design against, and it is why the generated prompt is required to carry a line about what to do when the input is thin.
What it deliberately will not write
The generator is instructed to refuse three habits that are common in shared prompt libraries and cost you output quality.
Flattery framing. You are a world class expert in growth marketing does not change what the model retrieves or how it reasons. It fills context. Where a role genuinely changes vocabulary and audience, the generator keeps it.
Questions before answers. A prompt that opens a conversation is fine when you are exploring. It is wrong when you will run this thing forty times, because it turns a one step job into a negotiation. The generated prompt states its assumptions, labels them, and produces the output.
Invented specifics. Every generated prompt carries a constraint forbidding made up figures, statistics and sources. This is not a style preference. A prompt that produces a number you then publish has moved a hallucination into your marketing, and the AI humanizer prompt has the same rule for the same reason.
Where to point it
The jobs worth generating a prompt for are the ones you will run more than five times: weekly reporting, triage, first draft briefs, rewriting to a house style, turning raw notes into a structured record. Anything you do once is faster asked directly.
For SEO and content work specifically, most of the common jobs are already written up in the prompt library, tested and with their inputs documented, so check there before generating a new one. Use this when the job is specific to how your team works, which is exactly the case a library cannot cover.
Once the prompt is producing pages that get published, the thing worth checking is not the prompt any more but the page: run it through the AI content readiness checker to confirm a passage can actually be lifted out of what you shipped.
You write prompts. I will describe a job I want done repeatedly. Return one
reusable prompt that does it, built to run on a fresh conversation with no
memory of this one.
Before you write it, work out the following silently and do not show me your
reasoning:
- What the output physically is: a table, a list, a document, a rewrite, a
number, a decision.
- What information the prompt cannot function without, and what it can infer.
- The most likely way a model gets this job wrong.
Then produce exactly these five sections, in this order.
1. THE PROMPT
A complete prompt in a code block, written in the second person to the model,
containing:
- The task in one opening sentence, with the deliverable named in it.
- The inputs as clearly marked placeholders in square brackets and capitals.
- The steps, numbered, only where order actually matters.
- The exact output format, including the column names if it is a table and
the maximum length if length matters.
- A constraints block that forbids the specific failure you identified,
forbids inventing figures, statistics or sources, and instructs the model
to state assumptions and continue rather than asking questions first.
- One line telling the model what to do when the input is missing or thin,
rather than leaving it to guess.
2. VARIABLES
A table: Placeholder | What to put in it | What happens if it is vague.
The third column is the useful one. Be specific about the failure.
3. TEST INPUTS
Three sets of inputs to run it on: one ordinary, one at the edge of what it
should handle, and one that should make it refuse or flag rather than answer.
For each, say in one line what a correct response looks like, so I can tell
a pass from a plausible failure.
4. FAILURE MODE
The one way this prompt will most likely fail in real use, and the single
line I would add to fix it if it does. Do not list five risks. Name the one
you actually expect.
5. WHAT I LEFT OUT
Anything I asked for that you deliberately did not put in the prompt, and
why. If a request would make the output longer without making it better, or
would ask the model for something it cannot know, say so here.
Constraints on you:
- Do not write flattery into the prompt. No world class expert, no you are
an award winning anything. Role framing that does not change the output is
noise that costs context.
- Do not produce a prompt that asks me questions before answering, unless I
explicitly say the job needs a conversation.
- Do not invent domain facts, figures or sources inside the prompt.
- Do not exceed 400 words in the prompt itself. If the job genuinely needs
more, say so in section 5 and split it into two prompts.
- Do not ask me anything before producing all five sections. State your
assumptions at the top, labelled, and continue.
The job: [WHAT YOU WANT DONE, IN A SENTENCE OR TWO]
Who the output is for: [THE READER OR SYSTEM THAT CONSUMES IT]
A good answer looks like: [WHAT DONE LOOKS LIKE, OR PASTE AN EXAMPLE]
Constraints: [ANYTHING FIXED: LENGTH, TONE, FORMAT, THINGS TO NEVER DO]What to change
Everything in square brackets is yours to replace. Nothing else needs editing.
[WHAT YOU WANT DONE, IN A SENTENCE OR TWO]- The job, described as an outcome rather than a topic. Write a weekly summary of our support tickets that flags the three themes worth acting on gets you a working prompt. Support tickets gets you a generic assistant.
[THE READER OR SYSTEM THAT CONSUMES IT]- Who reads the output, or what parses it. This decides format more than anything else you supply. An engineer reading it in a pull request, a client in an email and a script expecting JSON need three different prompts for the same job, and without this line you get the middle one by default.
[WHAT DONE LOOKS LIKE, OR PASTE AN EXAMPLE]- One example of a good output is worth three paragraphs of description. Paste a real one you liked, even an imperfect one, and the generated prompt will encode its shape. If you have none, describe the shape: how long, what order, what it opens with.
[ANYTHING FIXED: LENGTH, TONE, FORMAT, THINGS TO NEVER DO]- The rules that would make you reject the output. Never mention competitors by name, always under 200 words, never use bullet points, always include the date range. These become the constraints block, which is the part of a generated prompt that keeps working after the novelty wears off.
How to run it
- 01Describe the job as an outcome
Say what should exist when the prompt has finished running. Most weak prompts are weak because the person writing them named a subject rather than a deliverable, and the model then picks a format for you.
- 02Paste one example of a good output
This is the highest value thirty seconds in the process. A single concrete example fixes length, order, tone and level of detail at once, and it is the input people skip most often.
- 03Run the three test inputs before you use it on anything real
Section 3 exists so the prompt gets checked rather than trusted. The third test is the important one: if the prompt confidently answers the input it should have refused, it will do the same thing on your real data and you will not notice.
- 04Fix the failure mode only if it happens
Section 4 names the expected failure and the one line that fixes it. Add that line after you have seen the failure, not before. Prompts collapse under pre emptive rules, and every constraint you add costs attention the model could have spent on the task.
- 05Save it with its variables, not as a paragraph
Keep the prompt and its variable table together wherever your team stores prompts. A prompt separated from the description of its inputs gets pasted with the placeholders still in it, which is the most common way a good prompt produces a bad answer on its second use.
Questions people ask
What is a ChatGPT prompt generator?
A prompt that writes other prompts. You describe the job you want done and it returns a reusable prompt with the placeholders, the output format and the constraints written in, rather than you assembling those by trial and error. It is one prompt pasted into any assistant, not a separate tool or subscription.
Why does the generated prompt include test inputs?
Because a prompt that has only been run once has not been tested, it has been demonstrated. The three inputs cover the ordinary case, the edge case and the case where the correct response is to refuse or flag a gap. The third one catches the failure that matters: a model answering confidently from an input that did not contain the answer.
Should I tell the model to act as an expert?
Rarely, and this generator is instructed not to. Role framing changes output where the role changes the vocabulary or the audience, for example writing for clinicians rather than patients. Telling a model it is world class changes nothing measurable and spends context you could have spent on the actual instruction.
Does this work in Claude and Gemini as well as ChatGPT?
Yes. It contains no ChatGPT specific syntax. This page was run once on Claude, where all five sections appeared and the constraints were respected. One thing to expect: section 5, what was left out, comes back close to empty when your brief is clean, because there was nothing to refuse. That is correct rather than broken.
How is this different from a prompt template?
A template is a shape you fill in yourself. A generator reads your job description and decides the shape, including which steps need ordering and what the output format should be. If you already know the shape you want, our [ChatGPT prompt template](/prompts/chatgpt-prompt-template/) is faster. If you are staring at a blank box, start here.
Unsubscribe in one click. We never pass your address on.