I have a folder on my laptop called "Prompt Failures."
It started as a joke. Now it has forty-one entries.
Most of them are bad. A few are genuinely embarrassing. But the reason I keep that folder is that every single failure taught me something about what ChatGPT actually needs in order to produce something I can use.
And after two years of writing prompts at my desk, I've noticed that the ones that work all have the same five things in common.
I call it the Five-Part Prompt. It's not a magic formula, and it won't make ChatGPT smarter. But it will reliably get you a first draft you can actually work with, instead of a vague paragraph you have to throw away.
Let me show you the structure, then show you what happens when you skip each part.
The Five Parts
Here's the skeleton. I'll break down each piece after.
Role — who ChatGPT should act as
Task — what you want produced
Context — what it needs to know
Constraints — what rules it must follow
Format — what the output should look like
That's it. Five lines. Takes about ninety seconds to write, and it has saved me from more bad drafts than I can count.
Part One: Role
The role tells ChatGPT which hat to wear.
This sounds like fluff, but it isn't. The same task produces very different output depending on who you say is doing it.
Compare these two openings:
"Write a summary of this project update."
"You are an operations coordinator writing a status update for a manager who has thirty seconds to read it."
The first one gets you a summary. The second one gets you a summary that's actually shaped for a reader.
I use role framing constantly for email drafting. "You are a colleague who needs to decline a request without damaging the relationship." "You are a project assistant writing to a vendor about a missed deadline." The role sets the tone before I've said anything else.
One caution: don't overdo it. "You are a world-class communications expert with twenty years of experience" doesn't help. It just adds noise. Keep it simple and specific to the actual situation.
Part Two: Task
The task is the one thing you want produced. Singular.
This is where I see the most common mistake. People ask for five things at once and then wonder why all five come back mediocre.
Bad version:
"Summarize this report, pull out the action items, suggest next steps, and make it sound better."
Good version:
"Turn this report into a one-page summary with a clear recommendation at the top."
Do one thing. If you need five things, run the prompt five times, or build them into a workflow—that's what my Monday-Proof Workflows posts are for.
The task should also be specific about the output, not just the activity. "Summarize this" is vague. "Summarize this into three bullets for someone who hasn't read the original" is specific.
Part Three: Context
Context is the information ChatGPT needs but doesn't have.
This is where most people under-deliver, and it's the single biggest reason first drafts come back generic. ChatGPT doesn't know your workplace, your audience, your constraints, or what happened last week. If you don't tell it, it will guess—and its guess will be based on the average of everything it has ever read, which is not your situation.
What I usually include:
Who the output is for — my manager, a client, my team, my spouse
What they already know — so ChatGPT doesn't over-explain
What the situation is — a delay, a request, a conflict, a routine update
What I've already tried — if this is a revision, say so
Here's a real example from last week. I needed to write an email about a shipment delay.
Weak context:
"Write an email to a client about a delayed shipment."
Strong context:
"Write an email to a client about a delayed shipment. The client has worked with us for three years and values directness over politeness. The delay is one week, caused by a carrier issue on our end. This is the second delay this quarter. We're offering a partial credit."
Same task, completely different output. The second version gives ChatGPT enough to be useful.
The Context Trap
There's a trap here, though, and it's the one I care about most.
Context means situation context, not private data.
I never paste client names, account numbers, coworker names, or anything marked confidential. I describe the shape of the problem and leave the specifics out. "A client of three years" instead of the actual client name. "A carrier issue" instead of the actual carrier.
ChatGPT doesn't need the identifying details to help you write a better email. It needs to understand the situation. Those are different things, and keeping them separate is how you use this tool safely at work.
Part Four: Constraints
Constraints are the rules. This is the part that separates a prompt that works from one that produces garbage.
Constraints do three jobs:
They stop ChatGPT from doing things you don't want
They tell it what to do when information is missing
They set boundaries on length, tone, and scope
Here are the constraints I use most often:
"Do not invent any names, dates, or numbers."
"If information is unclear, write 'UNKNOWN' instead of guessing."
"Keep it under 150 words."
"Do not use the phrase 'I hope this finds you well.'"
"Do not add a conclusion paragraph."
"Do not use bullet points."
That fourth one is not a joke. Left alone, ChatGPT will absolutely open every email with "I hope this email finds you well," and I will absolutely delete it every single time.
The most important constraint is the "do not invent" rule. ChatGPT fills gaps, and it fills them confidently. Explicitly telling it to flag uncertainty instead of papering over it changes the output dramatically.
Part Five: Format
Format tells ChatGPT what shape the answer should take.
Without it, you get paragraphs. Sometimes that's fine. Often it isn't.
Format instructions I use:
"Three bullets, no more than fifteen words each."
"A short paragraph followed by a numbered list."
"A table with two columns: Task and Owner."
"One sentence per item."
Format is also where you decide the length. ChatGPT defaults to longer than you probably want. If you want short, say short. If you want a specific word count, give it one.
The Whole Thing, Assembled
Here's a real five-part prompt I've used. This one is for turning a messy request into a clear email.
Role: You are an operations coordinator writing on behalf of a team.
Task: Draft an email declining a meeting request and proposing an alternative.
Context: The requester is a peer from another department. We've worked together before and the relationship is good. The requested meeting is about a topic that isn't urgent. I'm available next week but not this week.
Constraints: Keep it under 120 words. Do not invent any dates beyond "next week." Do not apologize more than once. Do not use "I hope this finds you well."
Format: A short opening line, one sentence proposing the alternative, and a sign-off. No bullet points.
That prompt produces something I can send with maybe two small edits. Compare that to "write an email declining a meeting" and you can see why the five-part version wins.
What Happens When You Skip Each Part
I've tested this. Here's what breaks.
Skip Role: The tone is generic. It reads like a form letter.
Skip Task: ChatGPT wanders. You get a little of everything and a lot of nothing.
Skip Context: The output is technically correct and completely useless. It could apply to anyone, which means it applies to no one.
Skip Constraints: ChatGPT invents details, runs long, and adds a cheerful conclusion paragraph you didn't ask for.
Skip Format: You get dense paragraphs when you wanted bullets, or bullets when you wanted prose.
None of these are catastrophic on their own. But stack two or three, and you're rewriting the whole thing from scratch—which means you spent more time prompting than you saved.
The Test Card
Task: Build a reusable five-part prompt structure for first drafts.
Prompt or workflow: Role, Task, Context, Constraints, Format—written out in five labeled lines.
Starting conditions: A vague task, a real audience, and no existing draft.
Time before ChatGPT: Writing a first draft from scratch: 20–30 minutes for a typical work email or summary.
Time after ChatGPT: About 3 minutes to write the prompt, 90 seconds to generate, 5–10 minutes to edit. Call it 10–15 minutes total.
Editing required: Light to moderate. Well-constrained prompts cut the editing roughly in half compared to vague ones.
What went wrong: Early versions invented deadlines and names. Fixed by adding the "do not invent" constraint and a placeholder rule for missing information.
Privacy notes: Context describes situations, never identifies people, clients, or accounts. All names replaced with generic roles before pasting.
Who should not use this method: Anyone who needs a final draft, not a first one. Anyone who won't review the output—the constraints reduce errors but don't eliminate them. And anyone whose task requires information they can't describe without including private details.
Why This Works
The five-part prompt isn't clever. It's just complete.
Most bad prompts fail because they leave ChatGPT to guess at something only you know—the audience, the tone, the length, the rules. Each guess is a small risk. Five guesses is a bad draft.
Writing out the five parts takes an extra ninety seconds. It saves you a full rewrite. That trade is worth making every single time.
I tried it at my desk so you don't have to. Useful beats impressive—and a prompt that produces a usable draft beats a prompt that sounds clever.
