Most people aren’t bad at using ChatGPT, Claude, or other popular, similar AI tools.
They’re bad at explaining what they want, and they’re hoping the AI will magically know all of the context they’re leaving out.
They type something like:
Write me a marketing plan.
Then ChatGPT has to figure out what kind of business they own, what they’re selling, who buys it, what their budget is, what’s already working, what isn’t working, and approximately 37 other things that apparently weren’t important enough to mention.
Then the output comes back generic and bad.
And ChatGPT gets blamed.
Aww.
After writing, testing, rewriting, and occasionally beating the hell out of a ridiculous number of prompts, I’ve broken my ideal ChatGPT prompt into 10 components.
These are kind of like ChatGPT prompt hacks, but actually more like a framework you can use and come back to later.
I’ve also assigned each one a percentage based on how much practical impact I think it generally has:
- Context: 20%
- Objective: 15%
- Input Data: 15%
- Role: 10%
- Instructions: 10%
- Constraints: 8%
- Output Format: 8%
- Examples: 5%
- Iteration Request: 5%
- Quality Checks: 4%
That adds up to exactly 100%, which makes the whole thing look suspiciously scientific.
So, one important disclaimer before someone with a PhD sends me an angry email:
Those percentages are my practical weighting system. They aren’t numbers published by OpenAI or established by some giant peer-reviewed prompting study.
There also isn’t one scientifically proven to be a “perfect” prompt structure containing exactly 10 components.
This is a framework.
And it’s a damn useful one.
OpenAI’s own current guidance recommends many of the same underlying ideas: be clear and specific, provide enough relevant context, clearly describe the desired outcome and format, use examples when useful, and refine prompts based on the results. OpenAI also notes that prompting methods can work differently across different models.
In other words, don’t worship the percentages like a god.
However, use the ingredients.
Let’s party.
1. Context: 20%
Context gets the biggest piece of my imaginary prompting pie chart.
For good reason.
Context covers everything surrounding your request, from your business goals and industry to those unspoken company rules. It’s the essential background that helps the AI understand the specific reality you’re working within.
OpenAI specifically recommends providing enough context for the model to understand what you’re asking.
Its current API documentation also describes context as useful for supplying information outside the model’s training data or restricting an answer to specific source material.
Bad Context
Here’s an example of bad context:
Create a strategy for increasing sales.
Okay.
Sales of what?
To whom?
At what price?
Through which channels?
What’s already working?
What failed?
ChatGPT now has to fill in those blanks, and it can’t, because it doesn’t know.
Better Context
Here’s an example of better context:
My company sells project management software to remote teams with 10 to 100 employees. Our main challenge is that buyers think we’re too expensive compared to free project management tools.
Now we’re getting somewhere.
ChatGPT knows what you sell, who buys it, and what problem you’re trying to solve.
But More Context Isn’t Automatically Better
This is an important distinction that you need to understand.
You want relevant context, not every piece of information you’ve accumulated since birth.
Modern models can accept a lot of information, but there are still context-window limits, and dumping unrelated material into a prompt can make the important stuff harder to distinguish. OpenAI specifically recommends including relevant context and planning around the model’s available context window.
Don’t attach your company’s 184-page employee handbook to a prompt about writing an Instagram caption for your business unless Karen’s dental insurance somehow matters.
Pro tip: If you repeatedly use the same background information, store it somewhere reusable. Depending on how you use ChatGPT, that could include Custom Instructions, Project instructions, uploaded project files, or another persistent source of context. Then you don’t have to write your entire professional autobiography every time.
2. Objective: 15%
Next comes the objective.
In other words:
What exactly do you want ChatGPT to accomplish?
Vague objectives create vague outputs.
OpenAI’s current ChatGPT guidance explicitly recommends being clear, specific, and precise about what you’re asking the model to do.
People constantly write things like:
Help me with marketing.
“Help” could mean about 900 different things.
Do you want research?
Ideas?
An audit?
A strategy?
A rewritten landing page?
An email campaign?
Someone to reassure you that spending your retirement savings on an AI-powered toaster company is a fantastic idea?
Define the finish line.
Bad Objective
Here’s an example of a bad objective:
Tell me about marketing.
Better Objective
Here’s an example of a better objective:
Create a 90-day content marketing strategy for a SaaS startup targeting small businesses.
Much better.
Now the model knows what successful completion actually looks like.
Pro tip: Replace vague verbs such as “help” with verbs that describe an action or deliverable.
For example:
- Create
- Analyze
- Compare
- Diagnose
- Rewrite
- Rank
- Summarize
- Identify
- Recommend
- Critique
Make the AI’s job obvious.
3. Input Data: 15%
If ChatGPT needs information to complete the task, give it the information.
Groundbreaking stuff, I know.
Input data could include:
- Customer reviews
- Meeting notes
- Analytics
- Interview transcripts
- Research reports
- Sales numbers
- Website copy
- A rough draft
- Survey responses
- Product specifications
- Competitor information
This is one of the biggest differences between generic prompting and useful prompting.
Weak:
Why are customers canceling my software subscription?
Much better:
Analyze these 200 cancellation survey responses and identify the five most common reasons customers cancel.
Now ChatGPT has actual evidence to work with.
Separate Your Input From Your Instructions
When a prompt contains a lot of source material, clearly separate the material from your commands.
You can use Markdown headings, quotation marks, XML-style tags, or other obvious delimiters.
For example:
<customer_feedback>
[PASTE CUSTOMER FEEDBACK HERE]
</customer_feedback>
This isn’t some Reddit neckbeard prompting superstition.
OpenAI’s current documentation specifically recommends Markdown and XML as ways to establish logical boundaries inside prompts. XML tags can identify where supporting material begins and ends, while Markdown headings and lists can establish hierarchy.
That becomes increasingly useful when your prompt starts looking like a small novel.
4. Role: 10%
Role tells ChatGPT what perspective it should use when approaching the task.
For example:
Act as a senior software engineer.
Or:
Act as an experienced SEO strategist.
Or:
Act as a B2B SaaS CFO evaluating this proposal from the perspective of profitability, cash flow, and financial risk.
OpenAI’s current prompt documentation actually uses an Identity section in its recommended prompt structure. It defines that section as describing the assistant’s purpose, communication style, and high-level goals.
One Claim I Wouldn’t Make
You’ve probably heard people say that assigning a role “activates different knowledge clusters inside the model.”
That sounds cool.
It also makes the whole thing sound like you’re opening secret rooms inside ChatGPT’s brain.
There’s no need to make that claim.
A more defensible explanation is simpler:
Roles provide additional instructions about perspective, priorities, expertise, and style.
That’s enough.
Make the Role Useful
Weak:
You’re an expert.
Expert in what?
Better:
Act as a senior B2B SaaS marketing strategist specializing in companies with less than $5 million in annual revenue.
Better still:
Act as a senior B2B SaaS marketing strategist with 20 years of experience, specializing in companies with less than $5 million in annual revenue. You specifically have vast knowledge in prioritizing tactics for two-person marketing teams.
Now the role actually changes how the task should be approached.
Don’t add a role just because somebody on LinkedIn told you every prompt needs one.
Use it when the perspective matters.
5. Instructions: 10%
Instructions explain what ChatGPT should actually do.
This is the part everybody already understands.
The problem is that many people treat Instructions as the entire prompt.
For complicated tasks, numbered steps can make a big difference.
For example:
- Analyze the customer feedback.
- Identify the three most common complaints.
- Rank them by likely impact on customer retention.
- Recommend one practical solution for each complaint.
- Explain the reasoning behind your ranking.
OpenAI recommends ordered steps when there is a particular workflow you want a model to follow. Its prompting guidance specifically advises using ordered lists for tasks with defined sequential steps.
That’s a lot better than burying six different commands inside a 400-word paragraph.
Don’t make the robot dig through your life story looking for its chores.
6. Constraints: 8%
Constraints establish boundaries.
For example:
Maximum 500 words.
The total budget can’t exceed $5,000.00.
Only use the information I provided.
Don’t recommend paid advertising.
Keep the reading level around 8th grade.
Recommendations must be possible for one person to implement.
Constraints are great because they force the answer into your actual reality.
And this is also where you can attack annoying AI habits.
Negative Constraints Work, But There’s a Better Trick
I use negative constraints constantly.
For example:
Don’t use em dashes.
Don’t t use corporate jargon.
Do not use the words “delve,” “crucial,” or “tapestry.”
Do not add an introductory paragraph.
These can absolutely help steer the output.
But here’s an important improvement to my original framework:
Whenever possible, don’t ONLY tell ChatGPT what NOT to do. Tell it what to do instead.
OpenAI explicitly recommends this approach. Its prompting guide says that instead of merely prohibiting an unwanted behavior, it’s often better to describe the desired replacement behavior.
For example:
Less useful:
Don’t ramble.
Better:
Answer in no more than four concise paragraphs and lead with the recommendation.
Less useful:
Don’t use complicated language.
Better:
Use everyday language and keep the reading level around 8th grade.
Less useful:
Don’t ask for private information.
Better:
If identifying information would normally be required, explain how the user can complete that step privately.
You can still use negative constraints.
I sure as hell do.
Just give the model a road to drive on after you tell it where the cliffs are.
7. Output Format: 8%
You’ve told ChatGPT what to do.
Now tell it what the finished product should look like.
Want a table?
Ask for one.
Want five numbered recommendations?
Ask for them.
Want Markdown?
Ask for it.
Want JSON?
Ask for it.
Want a 1,500-word article using H2 sections with an FAQ at the bottom?
You know the drill.
OpenAI’s prompting guidance specifically recommends stating desired output formats and notes that examples can improve adherence to those formats.
Example
Present your recommendations in a table with three columns: Problem, Impact, and Proposed Solution.
That one sentence might save you from manually reorganizing an ugly blob of text afterward.
Output formatting becomes especially useful when the answer will be copied into another program or workflow.
One small technical note: if you’re developing with the OpenAI API and require reliably structured machine-readable output, OpenAI also offers Structured Outputs for enforcing JSON schemas. Merely saying “give me JSON” isn’t always the strongest option in a production system.
For regular ChatGPT users, though, telling it the structure you want goes a long way.
Don’t order mashed potatoes and complain when you wanted French fries.
Specify the shape.
8. Examples: 5%
Examples show ChatGPT what success looks like. So many people leave this out.
This is often called few-shot prompting.
Fancy name but simple concept.
You give the model one or more examples showing the relationship between an input and the desired output.
For example:
Input: Customer complains about pricing.
Output: Tell them to buy from our awful, yet low-priced competitors instead.
OpenAI’s documentation specifically describes few-shot prompting as steering a model by providing input/output examples from which it can pick up the desired pattern. It recommends using diverse examples when appropriate.
But Don’t Automatically Add Examples to Everything
Examples cost space and can sometimes unnecessarily constrain a model.
OpenAI’s API guidance recommends starting zero-shot, meaning without examples, and adding few-shot examples when the simpler approach isn’t producing the behavior you need.
That’s a smart rule.
Try the simple prompt.
If ChatGPT keeps screwing up the same thing, show it what “right” looks like.
Examples are particularly useful for:
- Tone
- Classification
- Data extraction
- Repetitive workflows
- Specific formatting
- Customer support responses
- Highly particular writing styles
There’s one other catch.
Models can imitate your examples a little too faithfully.
OpenAI warns that supplied sample phrases can sometimes lead to repetitive responses, so your examples should demonstrate the pattern you want without accidentally turning one sentence into the model’s new favorite catchphrase.
9. Iteration Request: 5%
Prompting doesn’t need to be a one-shot event.
OpenAI’s own ChatGPT guidance describes prompting as an iterative process: start with a prompt, review what comes back, then adjust the wording, context, or request based on the result.
In other words:
Talk to the damn thing.
You can also build iteration directly into the prompt.
For example:
Generate three distinct headline options. Compare their strengths and weaknesses, then recommend the strongest one.
Or:
Give me a conservative strategy, a moderate strategy, and an aggressive strategy.
Or:
Produce five concepts that approach the problem from substantially different angles.
This works especially well for creative tasks because there often isn’t one objectively perfect answer.
Instead of asking ChatGPT to hit a bullseye on one throw, give yourself several things to choose from.
You’re still the boss.
Unfortunately, that means somebody has to make the final decision.
10. Quality Checks: 4%
The final component is quality control.
For example:
Before finalizing the answer, check that every recommendation follows my budget constraint, is supported by the data provided, and doesn’t contradict another recommendation.
That’s a good use of a quality check because the criteria are concrete.
You can also ask things like:
Identify unsupported assumptions.
Verify that every requirement in my instructions was followed.
Check your calculations.
Flag claims that aren’t supported by the provided source material.
Test the code before presenting the final version.
OpenAI’s current GPT-5.6 guidance recommends validation and testing for tasks such as coding, and more broadly recommends building evaluations when prompt reliability actually matters.
Don’t Treat Self-Review as a Fact-Checking Machine
Here’s another part of my original framework I’d tighten.
Asking ChatGPT to “check itself for factual accuracy” doesn’t magically transform questionable information into verified information.
If the model doesn’t have a trustworthy source available, it can potentially review an incorrect claim and still decide it looks fine.
For factual research, a better instruction is something like:
Verify factual claims against reliable sources. Cite those sources. Clearly identify anything you could not verify.
That’s much better than:
Make sure you’re right.
The AI isn’t your mom checking your homework while holding the answer key.
Give it an actual verification method when accuracy matters.
The 10-Part Perfect ChatGPT Prompt Template
Now let’s assemble the whole monster.
1. Context
My company sells [PRODUCT/SERVICE] to [TARGET AUDIENCE].
Our current situation is [BACKGROUND].
The biggest challenge is [PROBLEM].
Our goal is [BUSINESS GOAL].
Only use the background above when it’s relevant to the task.
2. Objective
Your objective is to [SPECIFIC ACTION] and produce [SPECIFIC DELIVERABLE].
3. Input Data
<input_data>
[YOUR SOURCE MATERIAL]
</input_data>
4. Role
Act as a [SPECIFIC ROLE] specializing in [SPECIALTY].
Approach the task from the perspective of [RELEVANT PRIORITIES].
5. Instructions
Follow these steps:
1. Analyze [X].
2. Identify [Y].
3. Compare [Z].
4. Recommend [ACTION].
5. Explain the evidence supporting your recommendation.
6. Constraints
Keep the response under [WORD COUNT].
The maximum budget is [BUDGET].
Only use [ALLOWED INFORMATION].
Avoid [UNWANTED BEHAVIOR].
Use [DESIRED ALTERNATIVE] instead.
7. Output Format
Present the answer as [TABLE / NUMBERED LIST / REPORT / JSON / ETC.].
Include these sections:
1. [SECTION]
2. [SECTION]
3. [SECTION]
8. Examples
Use the following example to understand the desired pattern.
Input:
[EXAMPLE INPUT]
Output:
[EXAMPLE OUTPUT]
Follow the pattern, but do not copy phrases unnecessarily.
9. Iteration Request
Create three substantially different alternatives.
Compare them against the objective above and recommend the strongest option.
10. Quality Checks
Before finalizing:
1. Check that every instruction was followed.
2. Check that all constraints were respected.
3. Identify unsupported assumptions.
4. Verify factual claims against available reliable sources when verification is required.
5. Clearly flag anything you could not verify.
There you go.
Your innocent little prompt now has a better management structure than some companies I’ve worked with.
Do You Really Need All 10 Components?
No.
Please don’t turn this framework into prompt bureaucracy.
You don’t need this before asking ChatGPT whether it’s going to rain:
ROLE: You are an elite meteorological strategist with 30 years of atmospheric experience.
CONTEXT: I am a 38-year-old male currently wearing shorts.
OBJECTIVE: Determine precipitation probability.
For a simple request, you might only need:
Objective + Instructions + Output Format
For an analytical business task:
Context + Objective + Input Data + Instructions + Constraints + Quality Checks
For writing:
Context + Objective + Role + Input Data + Instructions + Constraints + Examples + Output Format
For something you’ve tried three times and ChatGPT keeps screwing up:
Add Examples and Constraints.
The right prompt is the smallest prompt that reliably gives you the result you need.
More prompting isn’t automatically better prompting.
There Is Another Variable: The Model
Here’s something a lot of prompt frameworks leave out completely.
The model itself matters.
A prompt that works beautifully with one model may not behave exactly the same way with another.
OpenAI explicitly says prompting techniques can vary between GPT models and reasoning models, and even different versions within the same model family can respond differently. Current GPT-series models also benefit from precise instructions that explicitly provide the required logic and data.
This means you shouldn’t treat a prompt as some magical incantation carved into stone.
If you switch models and the output changes, test the prompt again.
Prompting is partly writing, but it’s also testing.
Wrapping It Up
So, is there literally one scientifically proven perfect ChatGPT prompt consisting of exactly 10 components?
No.
That would make a great headline, though.
What I do think exists is a practical collection of ingredients that dramatically improves your odds of getting the output you actually wanted.
You won’t need every component every time.
The useful skill is recognizing which component is missing when the response isn’t good enough.
For me, Constraints was probably the component I underused the most until I realized how much better responses became when I defined the boundaries more clearly.
Just remember that constraints work even better when you’re not merely yelling “DON’T DO THIS” at the robot.
Tell it what you actually want instead.
Which of these 10 components do you skip the most? Add a comment below and let me know.
Until next time, remember to run the prompts and prompt the planet.
