1. How to Use This Library
These prompts are starting points, not magic words. Each one is built on a validated structure — role, task, context, format — and tested to produce consistently useful output in ChatGPT (GPT-4o and later). But the best version of any prompt is one customized to your specific situation.
Each entry below includes the prompt text (formatted as a code block you can copy), a label explaining what it's for, and a brief explanation of why the structure works — the useful part. If you understand the why, you can adapt any of these to your needs in 30 seconds.
Note on model versions: These prompts are validated against GPT-4o and Claude 3.5+ as of April 2026. Earlier ChatGPT models (GPT-3.5) may produce less consistent output with complex role-setting prompts. If you're on the free tier, results may vary.
2. The Prompt Library
Blog post from outline
Content
You are a professional content writer who specializes in [industry] for [target audience]. Write a 900-word blog post based on this outline: [paste outline]. Tone: conversational but authoritative. Use H2 subheadings, short paragraphs (3 sentences max), and end with a specific actionable takeaway. Avoid buzzwords and filler phrases.
Why it works: Specifies word count, audience, format (H2s, short paragraphs), tone, and explicitly excludes common AI filler. Each constraint eliminates a decision the model would otherwise make for you — usually poorly.
Landing page copy
Copywriting
You are a direct-response copywriter. Write a landing page hero section for [product name], a [one-sentence product description]. Target customer: [describe customer]. Main pain point we solve: [pain point]. Desired outcome the customer achieves: [outcome]. Output: headline (under 10 words), subheadline (1-2 sentences), and 3 bullet points highlighting the core benefit. No hype language.
Why it works: Forces you to articulate your product positioning before writing. The role (direct-response copywriter) anchors the tone. The constraint "no hype language" specifically counteracts ChatGPT's tendency toward superlatives.
Edit for clarity and concision
Editing
Edit the following text for clarity and concision. Rules: remove filler words, shorten sentences over 25 words, eliminate passive voice where possible, keep all original meaning intact. Do not change the tone or add new information. Show the edited version only (no commentary). Text: [paste text]
Why it works: The explicit rules tell the model exactly what to optimize for. "Show the edited version only" prevents the chatty wrap-around commentary ChatGPT adds by default. The "keep all original meaning" constraint prevents over-editing.
LinkedIn post from talking points
Social
Write a LinkedIn post from these talking points: [list 3-5 bullet points]. Audience: [describe audience]. Goal: [awareness / engagement / lead generation]. Format: hook sentence (creates curiosity, not clickbait), 3-5 short paragraphs, end with a genuine question. Under 250 words. Write in first person. Do not use corporate language.
Why it works: "Creates curiosity, not clickbait" is a meaningful distinction that produces better first lines. First-person + no corporate language = the model writes in a human voice rather than brand voice. The format spec produces LinkedIn-native formatting.
Rewrite for a different audience
Adaptation
Rewrite the following text for [new audience — e.g., "a non-technical executive" or "a 12-year-old" or "a skeptical buyer"]. Keep the core argument intact. Adjust vocabulary, examples, and depth of explanation for the new audience. Preserve the approximate length. Original text: [paste text]
Why it works: The "preserve the approximate length" constraint prevents either a summary or a bloated rewrite. Specifying the audience in behavioral terms ("skeptical buyer") produces more targeted adaptation than a demographic label alone.
Debug a function
Debugging
You are a senior [language] developer. Debug the following function. First, explain what the function is supposed to do based on the code. Then identify the bug(s) and explain why each one causes the problem. Then provide a corrected version. Language: [language]. Function: [paste code]. Error I'm seeing: [paste error message or describe behavior]
Why it works: The three-step structure (explain → identify → fix) forces the model to reason before producing the corrected code, which catches subtle bugs the model might otherwise patch superficially. Providing the error message gives critical diagnostic context.
Write a function from spec
Generation
Write a [language] function that [describe what it does]. Requirements: [list specific requirements]. Edge cases to handle: [list edge cases]. Include brief inline comments for non-obvious logic. Do not include a main() or any code outside the function itself unless I ask.
Why it works: Explicitly listing edge cases dramatically reduces the chance of getting code that only works in the happy path. "Do not include a main()" prevents the model from padding the output with boilerplate you'll have to delete.
Code review
Review
Review the following [language] code. Check for: (1) bugs or potential runtime errors, (2) performance issues, (3) security vulnerabilities if any, (4) readability and naming conventions. For each issue found, quote the specific line and explain the problem. Then suggest a fix. If the code looks solid in a category, say so briefly rather than inventing issues. Code: [paste code]
Why it works: The four explicit categories prevent vague feedback. "Quote the specific line" grounds each suggestion. "If the code looks solid, say so briefly" counteracts the model's tendency to find problems even when there are none.
Explain code to a junior developer
Teaching
Explain the following code to a junior developer who knows basic [language] but hasn't encountered [specific concept — e.g., async/await, closures, decorators]. Walk through it line by line for the complex parts, use an analogy for [specific concept], and end with one practical "watch out for" tip. Code: [paste code]
Why it works: Anchoring to a specific knowledge gap ("knows basic Python but not async/await") calibrates the explanation depth. The analogy request produces more memorable explanations than pure technical description. The "watch out for" tip adds practical value beyond comprehension.
Convert pseudocode to working code
Generation
Convert the following pseudocode to working [language] code. Make reasonable assumptions about data types where not specified, but list those assumptions as comments at the top of the code. Do not add features beyond what the pseudocode describes. Pseudocode: [paste pseudocode]
Why it works: "List assumptions as comments" makes hidden decisions visible so you can catch them. "Do not add features beyond" prevents scope creep — ChatGPT tends to "improve" your design without asking, which often introduces complexity you didn't want.
Competitive landscape analysis
Strategy
You are a strategy analyst. Analyze the competitive landscape for [product/market]. Identify 3-5 major competitors, and for each: core value proposition, estimated customer segment, known strengths, known weaknesses. Then identify 2-3 gaps in the market that a new entrant could exploit. Format as a structured table followed by a brief gap analysis paragraph. Base your response on what is broadly known — do not invent specifics.
Why it works: The "do not invent specifics" instruction is critical — ChatGPT will fabricate competitor details if you don't explicitly prohibit it. The table + paragraph format separates data from analysis cleanly. Asking for exploitable gaps makes the output actionable.
SWOT analysis
Planning
Conduct a SWOT analysis for [company/project/idea]. Context: [2-3 sentences describing it]. For each quadrant (Strengths, Weaknesses, Opportunities, Threats), provide 3-4 specific, non-generic items. Avoid vague statements like "strong leadership" without grounding them in something concrete. Format as four sections with bullet points.
Why it works: "Avoid vague statements like 'strong leadership'" directly addresses the most common failure mode of AI-generated SWOT analyses. The context you provide anchors the model to your actual situation rather than a generic company template.
Executive summary from a long document
Summarization
Write an executive summary of the following document for a senior leader who has 3 minutes to read it. Structure: (1) one-paragraph situation overview, (2) key findings or decisions — max 5 bullet points, (3) recommended action in one sentence. Do not include background that the reader already has from context. Prioritize implications over description. Document: [paste document]
Why it works: The three-part structure is directly usable. "Prioritize implications over description" is the key distinction between a good executive summary and a content summary — most AI-generated summaries get this backwards.
Pro/con decision framework
Decisions
Help me think through this decision: [describe decision]. Key factors I care about: [list 3-5 factors, e.g., cost, reversibility, speed, risk]. For each option, evaluate it against my stated factors — not generic factors. Then give me your honest recommendation with the strongest argument for and the strongest argument against. I want your actual view, not a balanced "it depends" non-answer.
Why it works: Stating your factors upfront prevents the model from evaluating on its own priorities. "I want your actual view, not a balanced 'it depends'" produces a real recommendation rather than the diplomatic non-answer AI tools default to.
Market sizing estimate
Research
Give me a rough TAM/SAM/SOM estimate for [market/product]. Walk through each level of the funnel with your assumptions clearly stated at each step. Use a bottom-up approach: start from the addressable population, not a top-down industry report number. State your confidence level for each assumption. Make clear what would change the estimate most if the assumption were wrong.
Why it works: "State your assumptions" and "state your confidence level" produce a useful estimate rather than an authoritative-sounding number that's actually a guess. Bottom-up anchoring to population prevents the common error of citing inflated industry reports.
Topic deep-dive
Learning
Give me a comprehensive overview of [topic]. I already know [what you already know — e.g., "the basics of machine learning"]. I need to understand [specific gap — e.g., "how attention mechanisms work in transformers"]. Start with the key concepts I need before the main explanation. Use concrete analogies where helpful. End with 3 things I should read or explore next. Keep the total response under 700 words.
Why it works: Stating what you already know calibrates the explanation depth — the model won't re-explain basics you know or skip prerequisites you need. The 700-word limit prevents an overwhelming wall of information. The "what to explore next" section turns one answer into a learning path.
Literature summary
Research
Summarize the current consensus on [research topic] as of your knowledge cutoff. Structure: (1) what the evidence broadly shows, (2) where there is genuine disagreement or uncertainty, (3) what the most significant open questions are. Be explicit when something is well-established vs. contested vs. speculative. Do not present contested claims as settled fact.
Why it works: The three-part structure surfaces uncertainty rather than hiding it. "Do not present contested claims as settled fact" is the critical honesty constraint — ChatGPT tends to present everything with the same level of confidence unless you explicitly require calibration.
Explain a technical concept to a non-expert
Explanation
Explain [technical concept] to someone who has no background in [field] but is intelligent and motivated to understand it. Use one everyday analogy to introduce the core idea. Then explain how it actually works with enough precision that they could explain it to someone else. Explicitly flag where you are simplifying. Keep it under 400 words.
Why it works: "Enough precision that they could explain it to someone else" sets a higher comprehension bar than "make it simple." "Explicitly flag where you are simplifying" builds the reader's calibration. The analogy request produces comprehension, not just familiarity.
Steelman the opposing view
Critical Thinking
I hold the following position: [your position]. Give me the strongest possible case for the opposing view — not a strawman, but the actual best arguments a thoughtful opponent would make. Include the strongest empirical evidence or logical arguments for their side. Do not include weak or easily dismissed objections. After presenting their case, give me 2-3 things their view gets right that I should acknowledge.
Why it works: "Not a strawman, but the actual best arguments" is a meaningful distinction that the model responds to. The "things their view gets right" request forces productive intellectual honesty rather than a rebuttal list. Useful for building robust arguments or genuinely testing your own position.
Historical context for a current event
Context
Give me the historical context needed to understand [current topic or event]. Go back far enough to explain the root causes, not just the immediate background. Identify 3-4 key inflection points that shaped the current situation. Distinguish between widely agreed-upon historical facts and more contested interpretations. Format as a brief narrative, not a list.
Why it works: "Go back far enough to explain root causes" produces depth vs. recency bias. The contested/agreed distinction is the honesty constraint. Narrative format (vs. bullet list) produces more coherent causal reasoning for complex topics.
Cold outreach email
Outreach
Write a cold email to [role] at [type of company]. I'm offering: [one sentence on what you offer]. The main benefit for them specifically: [benefit]. The email should: be under 100 words, have no subject line (I'll write it), open with something specific to their role (not generic flattery), have a single clear call to action. Do not use the phrase "I hope this email finds you well" or any variation of it.
Why it works: 100-word constraint forces ruthless prioritization. "Specific to their role, not generic flattery" produces a better opening line. The explicit exclusion of "I hope this email finds you well" prevents the most common AI cold email opener — which signals an AI-written message to recipients.
Difficult conversation script
Management
Help me prepare for a difficult conversation with [role — e.g., "a direct report who missed targets"]. Context: [2-3 sentences on the situation]. Goal of the conversation: [what I want the outcome to be]. What I want to avoid: [e.g., "coming across as punitive" or "leaving the issue unresolved"]. Give me: an opening line, 3-4 key points to make, how to respond if they get defensive, and how to close toward a specific outcome.
Why it works: The "what I want to avoid" constraint is under-used but produces dramatically better scripts. The defensive response preparation is the most practically valuable part — most people know what they want to say, not what to do when it goes sideways.
Follow-up email after no response
Sales
Write a follow-up email to [role] who received my initial email [X] days ago and hasn't responded. Original context: [one sentence]. This follow-up should: add something of value (a relevant insight, a question, or a resource) rather than just checking in, be under 75 words, not guilt-trip or pressure the recipient, end with an easy yes/no question rather than an open-ended request. Tone: professional and low-pressure.
Why it works: "Add something of value rather than just checking in" is the core principle of effective follow-up. The yes/no question ending has meaningfully higher response rates than open-ended requests. "Do not guilt-trip" prevents the passive-aggressive tone ChatGPT defaults to for follow-ups.
Meeting recap email
Internal Comms
Write a meeting recap email based on these notes: [paste notes]. Recipients: [who gets this]. Format: opening line stating what was decided (not "we met to discuss"), numbered list of decisions made, numbered list of action items with owner and due date, single closing sentence. Keep it under 200 words. Do not use "per our discussion" or "as per."
Why it works: Decisions first (not discussion summary) respects the recipient's time. Owner + due date on action items eliminates the most common follow-up ambiguity. The opening line instruction forces specificity that most meeting recaps lack.
Saying no gracefully
Professional
Help me write a professional email declining [request — e.g., "a speaking engagement", "a vendor pitch", "taking on a new project"]. I want to: decline clearly (not leave ambiguity), not over-explain or apologize excessively, preserve the relationship, and leave the door open if appropriate. Context: [brief context on the situation]. Keep it under 100 words.
Why it works: "Decline clearly, not leave ambiguity" prevents the hedged non-answers that create confusion. "Not over-explain or apologize excessively" produces a more confident, professional tone. The relationship preservation + door-open instructions shape the closing line specifically.
3. Why These Prompts Work: The Four-Part Structure
Every effective prompt above shares the same underlying architecture. Once you see it, you'll see it everywhere — and you'll be able to build your own prompts from scratch rather than searching for one that fits.
Part 1
Role
Sets context for who the model is — expertise level, perspective, and tone. Without it, the model defaults to a generic helpful assistant, which is often not what you need.
"You are a senior copywriter who specializes in SaaS..."
Part 2
Task
The specific deliverable — what to produce, how long, what to include. Vague tasks get vague output. Every decision left to the model is a potential mismatch.
"Write a 3-paragraph follow-up email..."
Part 3
Context
Everything the model needs to know to do the task well: your audience, constraints, what you've tried, what you're trying to avoid. Think of it as your creative brief.
"Target: VP Sales at Series B SaaS. Competing with Salesforce..."
Part 4
Format
How to structure the output. Bullet list, table, narrative, headers, word count — every format constraint removes one more decision the model makes poorly.
"Respond in a table. Under 200 words. Do not include..."
You don't need all four in every prompt. A simple task might need only Role + Task. A complex deliverable needs all four. The key insight: every word in a well-written prompt is doing a specific job. If you can't explain why a phrase is there, it's probably not earning its space.
4. The Problem with Copying Prompts
Prompt libraries — including this one — are genuinely useful. But relying solely on pre-written prompts has three failure modes that become costly over time.
| Problem |
What happens |
Why it matters |
| Model drift |
ChatGPT is updated regularly. Prompts tuned for one version may underperform on the next. |
A prompt that worked in 2024 may need rewriting for GPT-4o in 2026. If you understand the structure, you can adapt in minutes. If you don't, you're stuck. |
| Context mismatch |
Generic prompts don't know your audience, your constraints, your industry, or your voice. |
The best version of any prompt is always customized. A prompt written for a SaaS company produces different quality than the same prompt for a healthcare startup. |
| No transfer |
You can copy a prompt, but you can't copy the skill. Novel situations don't have a pre-written prompt. |
About 80% of prompting situations are unique to you. A library covers 20% of what you actually need. The skill covers 100%. |
The honest takeaway: Use prompt libraries to accelerate your work right now. But treat each example as a case study in prompt structure — not a permanent solution. The ROI on understanding why a prompt works is higher than any collection of pre-built prompts.
5. Learning to Generate Your Own Prompts
PromptSharp is built specifically for this — turning prompt engineering from something you read about into something you can do automatically. The design is modeled on how Duolingo teaches language: practice in structured sessions until the skill is reflexive.
🎯
Role-Setting Track
Master the skill of calibrating persona, expertise level, and tone for different use cases.
8 missions · Beginner → Advanced
✍️
Writing & Editing Track
Prompts for content, copy, editing, rewriting, and tone adaptation for different audiences.
10 missions · All levels
💻
Technical Prompting Track
Code generation, debugging, documentation, and explanation prompts for developers.
8 missions · Intermediate+
📊
Analysis & Research Track
Prompts for structured analysis, research synthesis, decision frameworks, and summaries.
7 missions · Intermediate
📧
Communication Track
Professional writing: cold outreach, internal comms, difficult conversations, negotiations.
9 missions · All levels
🧩
Format & Structure Track
Controlling output format: tables, lists, markdown, JSON, narrative — for every context.
6 missions · Beginner
Each mission follows the same pattern: brief on the skill, blank box to write your prompt, then compare to an expert version. The gap between what you wrote and the expert version is the lesson. After 30 days of daily missions, the structure becomes automatic — you don't have to think about it.
6. Frequently Asked Questions
Can I just copy these prompts and use them as-is?
+
Yes — these prompts will work as starting points. But for best results, customize them to your context: your audience, your industry, your specific constraints. A prompt written for a generic use case rarely fits a specific one perfectly. The prompts here are validated structures, not magic words. Think of them as templates, not copy-paste solutions.
Do these prompts work on Claude, Gemini, and other AI tools too?
+
Yes. The underlying structure — role, task, context, format — transfers across models. ChatGPT, Claude, and Gemini all respond well to specific, structured prompts. You may need minor wording adjustments: Claude tends to prefer more explicit structure (XML tags for complex tasks); Gemini handles factual research prompts particularly well. The core pattern is universal.
Why do prompts sometimes stop working as well over time?
+
Because the models themselves change. OpenAI updates ChatGPT regularly, and prompts tuned for one version may produce different results on the next. Additionally, what works for your specific use case often needs to be adapted over time as your needs evolve. This is the main reason learning the underlying skill — not just collecting prompts — pays off more in the long run.
How do I customize a prompt for my specific situation?
+
Start with the structure: Role + Task + Context + Format. Replace the placeholder elements with your actual situation. Specify your audience, your constraints, and what "good output" looks like for you. If you're unsure what context to include, ask yourself: "What would I tell a new employee on their first day so they could do this task correctly?" That's usually exactly what the model needs.
What makes a ChatGPT prompt "good" vs "bad"?
+
A good prompt eliminates ambiguity. It tells the model who it is (role), what to produce (task), relevant background (context), and how to structure the output (format). A bad prompt leaves the model to guess on any of those dimensions — and whatever it guesses probably isn't what you wanted. Specificity is the key variable. More specific = better output, consistently.
Is there a faster way to learn prompt writing than reading examples?
+
Yes: deliberate practice with feedback. Reading examples builds recognition — you can identify a good prompt when you see one. Actually writing prompts builds the skill — you can generate a good prompt on demand. PromptSharp's mission-based system is specifically designed for the second type of learning: you get a task, write the prompt, then compare to an expert version. The gap is where the learning happens.