Vague vs Specific Prompts Compared
Side-by-side examples showing the dramatic difference specificity makes.
Vague vs Specific Prompts Compared is a free AI Prompt Engineering lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Prompt Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Side-by-Side Comparison Method
The fastest way to internalize prompt quality is to study specific rewrites side by side and analyze why each improvement works.
In this lesson we examine five vague prompts and their specific rewrites. For each pair, we identify the exact changes made and the mechanism by which each improvement guides the model to better output.
Pair 1: The Blog Post
Vague: 'Write a blog post about remote work.'
Specific: 'Write a 600-word blog post titled "The 3 Remote Work Habits That Killed My Productivity (And What I Do Now)" for an audience of mid-level software developers. First-person voice, conversational tone. Structure: 1 intro paragraph, 3 sections with H2 headings, 1 closing CTA to download a free template.'
Why it works: Adds word count, title (and therefore angle), audience, voice, tone, structure, and a specific ending element. Zero dimensions left to chance.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=800,
messages=[{
'role': 'user',
'content': (
'Write a 600-word blog post titled '
'"The 3 Remote Work Habits That Killed My Productivity (And What I Do Now)" '
'for an audience of mid-level software developers. '
'First-person voice, conversational tone. '
'Structure: 1-paragraph intro, 3 H2 sections (one per habit), '
'1 closing paragraph with a CTA to download a free productivity template.'
)
}]
)
print(response.content[0].text[:400], '...')Pair 2: The Code Review
Vague: 'Review my code.'
Specific: 'Review the following Python function. Focus only on: 1) correctness bugs, 2) edge cases not handled. Do NOT comment on style, naming, or formatting. Output format: numbered list of issues, each with: issue description (1 sentence), affected line(s), suggested fix (code snippet).'
Why it works: Defines the review scope (correctness + edge cases), explicitly excludes other dimensions (style/naming), and specifies a precise output structure with three fields per finding.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
code = (
'def get_user(users, user_id):\n'
' for user in users:\n'
' if user["id"] == user_id:\n'
' return user["name"]\n'
' return users[0]["name"]\n'
)
response = client.chat.completions.create(
model='gpt-4o',
messages=[{
'role': 'user',
'content': (
'Review the following Python function.\n'
'Focus ONLY on: 1) correctness bugs, 2) unhandled edge cases.\n'
'Do NOT comment on style, naming conventions, or formatting.\n'
'Output format: numbered list. Each item: issue (1 sentence), '
'affected line, suggested fix as a code snippet.\n\n'
+ code
)
}]
)
print(response.choices[0].message.content)Pair 3: The Email Subject Line
Vague: 'Write email subject lines for my newsletter.'
Specific: 'Write 10 email subject lines for a weekly newsletter about Python for data scientists. Each subject line must be under 50 characters, have an open rate hook (curiosity gap, numbered list, or surprising claim), and avoid spam trigger words like FREE or URGENT. Output as a numbered list with the hook type labeled in brackets.'
Why it works: Specifies quantity, length constraint, hook requirement, exclusion list, and a labeled output format — turning a vague creative task into a rules-based generation task.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=400,
messages=[{
'role': 'user',
'content': (
'Write 10 email subject lines for a weekly newsletter '
'about Python tips for data scientists. '
'Requirements:\n'
'- Each under 50 characters\n'
'- Must use one of these hooks: [CURIOSITY GAP], [NUMBER], or [SURPRISING CLAIM]\n'
'- No spam words: FREE, URGENT, ACT NOW, LIMITED TIME\n'
'- Output as numbered list with hook type in brackets at the end of each line'
)
}]
)
print(response.content[0].text)Pair 4: The Meeting Summary
Vague: 'Summarize this meeting transcript.'
Specific: 'Summarize this meeting transcript using the following format: 1) Meeting Purpose (1 sentence), 2) Key Decisions Made (bullet list, max 5), 3) Action Items (table with columns: Task, Owner, Deadline), 4) Open Questions (numbered list). If information is missing for a field, write N/A. Do not include any opinions — facts and commitments only.'
Why it works: Provides an exact template, specifies limits per section, defines the table schema, sets a fallback for missing data, and adds a tone constraint (facts only).
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
transcript = (
'John: We need to decide on the launch date. '
'Sarah: I think Q3 works. We need the API done first. '
'John: Agreed. Sarah, can you own the API? '
'Sarah: Yes, I can have it by July 15th. '
'John: Great. Who handles marketing? '
'Mike: I will, but I need the feature list first. '
'John: We still need to confirm pricing — tabled for next week.'
)
response = client.chat.completions.create(
model='gpt-4o',
messages=[{
'role': 'user',
'content': (
'Summarize this meeting transcript in this exact format:\n'
'1. Meeting Purpose: (1 sentence)\n'
'2. Key Decisions: (bullet list, max 5)\n'
'3. Action Items: (markdown table: Task | Owner | Deadline)\n'
'4. Open Questions: (numbered list)\n'
'Missing info: write N/A. Facts only, no opinions.\n\n'
'Transcript:\n' + transcript
)
}]
)
print(response.choices[0].message.content)Pair 5: The Explanation
Vague: 'Explain machine learning.'
Specific: 'Explain machine learning in 3 paragraphs for a product manager at a healthcare company who understands statistics but has never written code. Paragraph 1: what it is and how it differs from traditional programming. Paragraph 2: a real healthcare example (diagnosis or drug discovery). Paragraph 3: one common misconception to avoid. Max 200 words total.'
Why it works: Defines structure (3 paragraphs with assigned topics), audience (specific role + domain + background), content requirements per paragraph, and an overall word limit.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=350,
messages=[{
'role': 'user',
'content': (
'Explain machine learning in exactly 3 paragraphs. '
'Audience: a product manager at a healthcare company who understands statistics '
'but has never written code.\n'
'Paragraph 1: what ML is and how it differs from traditional programming.\n'
'Paragraph 2: a specific real-world healthcare example (diagnosis or drug discovery).\n'
'Paragraph 3: one common misconception non-technical people have about ML.\n'
'Max 200 words total. No bullet points — flowing prose only.'
)
}]
)
print(response.content[0].text)The Anatomy of a Good Rewrite
Looking across all five pairs, every effective rewrite does the same things:
- Replaces a vague verb ('write', 'review', 'explain') with a structured task
- Names the output format (list, table, paragraphs with assigned content)
- Adds measurable constraints (word count, number of items, character limits)
- Specifies the audience (role + background + context)
- Adds at least one exclusion rule (what to leave out)
# Pattern extractor: identify improvements between two prompts
def analyze_improvement(vague, specific):
improvements = []
words = specific.lower()
if any(str(n) in words for n in range(10, 10000)):
improvements.append('Quantitative constraint added')
if 'do not' in words or 'exclude' in words or 'avoid' in words or 'no ' in words:
improvements.append('Negative constraint added')
if 'audience' in words or 'for a' in words or 'targeting' in words:
improvements.append('Audience specified')
if 'format:' in words or 'table' in words or 'list' in words or 'paragraph' in words:
improvements.append('Output format defined')
if 'example' in words or 'such as' in words or 'like:' in words:
improvements.append('Example provided')
print('Improvements detected:')
for i in improvements:
print(f' + {i}')
vague = 'Write a blog post about remote work.'
specific = 'Write a 600-word blog post for mid-level developers with 3 H2 sections and a closing CTA. No bullet points. Avoid generic productivity advice.'
analyze_improvement(vague, specific)What Happens When Only One Dimension Is Added
Adding just one improvement helps — but partial specificity still leaves large gaps. Compare:
- 'Write a blog post about remote work' — no constraints
- 'Write a 600-word blog post about remote work' — length only; angle, audience, structure still vague
- 'Write a 600-word blog post about remote work for developers, conversational tone' — length + audience + tone; structure, CTA, heading style still vague
Each dimension you leave unspecified is a lottery. Add as many as you have information for.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Progressively more specific prompts
prompts = [
'Write about Python.',
'Write a 200-word article about Python.',
'Write a 200-word article about Python for beginners who know no programming.',
(
'Write a 200-word article about Python for beginners who know no programming. '
'Start with a real-world analogy. Use 3 short paragraphs. '
'End with one actionable first step they can take today.'
)
]
for i, p in enumerate(prompts, 1):
print(f'Prompt {i} ({len(p)} chars): {p[:80]}...' if len(p) > 80 else f'Prompt {i}: {p}')
print()Using the Comparison Pair Technique in Practice
The comparison pair technique is a powerful debugging tool. When you get a bad output:
- Save the vague prompt that produced bad output
- Identify the one dimension that caused the problem
- Write a specific rewrite targeting only that dimension
- Run both prompts and compare outputs
- Identify what still needs fixing — then add the next constraint
This scientific approach quickly teaches you which constraints matter most for your use case.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
def compare_prompts(prompt_a, prompt_b, label_a='A', label_b='B'):
client_ref = anthropic.Anthropic(api_key='sk-ant-your-key-here')
for label, prompt in [(label_a, prompt_a), (label_b, prompt_b)]:
response = client_ref.messages.create(
model='claude-opus-4-5',
max_tokens=150,
messages=[{'role': 'user', 'content': prompt}]
)
print(f'=== {label} ===')
print(prompt)
print('--- OUTPUT ---')
print(response.content[0].text)
print()
compare_prompts(
prompt_a='Explain APIs.',
prompt_b='Explain APIs in 3 sentences for a non-technical startup founder. Analogy required.',
label_a='VAGUE',
label_b='SPECIFIC'
)The Two-Minute Prompt Audit
Before sending any important prompt, run this 2-minute audit. For each question, if the answer is 'no', add the missing detail:
- Is the format named? (list / table / paragraph / JSON)
- Is the length specified? (word count / number of items)
- Is the audience described? (role + background)
- Is the goal clear? (what the output is for)
- Is there at least one exclusion? (what to leave out)
- Is there an example or template? (if style matters)
def two_minute_audit(prompt):
score = 0
checks = {
'Format specified': any(w in prompt.lower() for w in
['list', 'table', 'paragraph', 'json', 'bullet', 'sentence', 'word']),
'Length given': any(c.isdigit() for c in prompt),
'Audience named': any(w in prompt.lower() for w in
['for a', 'audience', 'targeting', 'developer', 'manager', 'beginner']),
'Exclusion added': any(w in prompt.lower() for w in
['do not', 'avoid', 'exclude', 'no ', 'without', 'never']),
'Goal stated': any(w in prompt.lower() for w in
['goal', 'purpose', 'so that', 'in order to', 'will be used']),
}
print('Prompt Audit:')
for check, passed in checks.items():
icon = 'PASS' if passed else 'FAIL'
print(f' [{icon}] {check}')
if passed: score += 1
print(f'Score: {score}/{len(checks)}')
two_minute_audit(
'Write 5 bullet-point suggestions for improving user onboarding '
'for a B2B SaaS app targeting first-time non-technical users. '
'Avoid suggestions that require engineering work. Each bullet: max 25 words.'
)Building Your Prompt Library
Every time you write a prompt that produces excellent output, save it. Build a personal prompt library organized by task type.
A good prompt library entry includes:
- The prompt template with placeholders like
[AUDIENCE],[WORD_COUNT] - The use case it was designed for
- The model and settings used
- A note on what makes it effective
Over time your library becomes your most valuable AI productivity asset.
# Example prompt library entry
prompt_library = {
'meeting_summary': {
'template': (
'Summarize the following meeting transcript in this format:\n'
'1. Purpose: (1 sentence)\n'
'2. Decisions: (bullet list, max 5)\n'
'3. Action Items: (table: Task | Owner | Deadline)\n'
'4. Open Questions: (numbered list)\n'
'Missing info: N/A. Facts only.\n\nTranscript:\n[TRANSCRIPT]'
),
'use_case': 'Post-meeting automation for Slack or Notion',
'model': 'claude-opus-4-5',
'temperature': 0,
'notes': 'Works best with verbatim transcripts, not paraphrased notes'
}
}
# Use the template
def run_meeting_summary(transcript):
template = prompt_library['meeting_summary']['template']
return template.replace('[TRANSCRIPT]', transcript)
print(run_meeting_summary('Alice: We decided to ship v2 next Friday...')[:200])Knowledge Check
Looking at the five comparison pairs in this lesson, which single change most consistently improved prompt quality across all five examples?
Vague vs Specific — Recap
The five comparison pairs reveal a consistent pattern in what makes prompt rewrites effective:
- Output structure is the highest-ROI improvement — always define it
- Word/item count eliminates length negotiation entirely
- Audience description calibrates vocabulary and depth automatically
- Exclusion rules prevent predictable generic content
- Partial specificity still leaves gaps — every unspecified dimension is a guess
- Prompt libraries capture winning templates for repeated reuse
Frequently asked questions
Is the “Vague vs Specific Prompts Compared” lesson free?
Yes — the full text of “Vague vs Specific Prompts Compared” is free to read here on the web, and the AI Prompt Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Prompt Engineering course, upgrade to CoddyKit PRO.
What will I learn in “Vague vs Specific Prompts Compared”?
Side-by-side examples showing the dramatic difference specificity makes. You practise AI Prompt Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start AI Prompt Engineering?
No prior experience is required. AI Prompt Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Vague vs Specific Prompts Compared” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this AI Prompt Engineering lesson?
Yes. Every AI Prompt Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Why Specificity Matters
- Removing Ambiguity from Prompts
- Adding Concrete Details
- Vague vs Specific Prompts Compared