0Pricing
AI Prompt Engineering · Lesson

Why Specificity Matters

How vague prompts lead to generic outputs — and how precision fixes it.

Why Specificity Matters is a free AI Prompt Engineering lesson on CoddyKit — lesson 1 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.

The Vagueness Problem

When you send a vague prompt, the AI fills in all the missing details with its best guess. Those guesses are based on the most statistically average interpretation — not your actual intent.

The result: generic, forgettable output that requires extensive rewriting. Specificity is the single most powerful lever you have for improving AI output quality.

Vague Prompt: Write About Dogs

Consider the prompt: 'Write something about dogs.'

The model must guess: What format? What length? What audience? What angle? It defaults to a safe, bland paragraph that could fit a children's encyclopedia.

Now compare: 'Write a 200-word Instagram caption for a golden retriever puppy's first day at the beach. Tone: playful and emotional. Include 5 relevant hashtags.'

The second prompt leaves nothing to chance.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

vague = 'Write something about dogs.'
specific = (
    'Write a 200-word Instagram caption for a golden retriever puppy\'s '
    'first day at the beach. Tone: playful and emotional. '
    'End with 5 relevant hashtags.'
)

for label, prompt in [('VAGUE', vague), ('SPECIFIC', specific)]:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=300,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'--- {label} ---')
    print(response.content[0].text)
    print()

Why Generic Output Happens

The model was trained on billions of text examples. When you say 'write about X', it generates the most common type of text about X it saw during training.

That tends to be:

  • Encyclopedic in tone
  • Medium length
  • Covering all major angles superficially
  • No distinct voice or purpose

Your specific constraints override these defaults and steer the model toward your actual need.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Default (vague) output
default_response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Write about coffee.'}]
)
print('DEFAULT OUTPUT (first 200 chars):')
print(default_response.choices[0].message.content[:200])
print()

# Constrained output
constrained_response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Write a 100-word product description for a single-origin Ethiopian pour-over coffee. '
            'Target audience: specialty coffee enthusiasts. '
            'Tone: sophisticated, sensory. Mention flavor notes: jasmine, blueberry, dark chocolate.'
        )
    }]
)
print('CONSTRAINED OUTPUT:')
print(constrained_response.choices[0].message.content)

The Five Specificity Dimensions

When writing a prompt, specify across five dimensions:

  1. Format — paragraph, bullet list, table, JSON, email
  2. Length — word count, sentence count, number of items
  3. Audience — who will read or use this output
  4. Tone — formal, casual, technical, persuasive, empathetic
  5. Goal — what the output is supposed to accomplish

You do not always need all five — but missing any one of them is an invitation for the model to guess wrong.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# All 5 dimensions specified
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=256,
    messages=[{
        'role': 'user',
        'content': (
            'Format: 3-bullet summary.\n'
            'Length: each bullet max 20 words.\n'
            'Audience: busy startup founders with no ML background.\n'
            'Tone: direct, no jargon.\n'
            'Goal: explain why fine-tuning an LLM is expensive.'
        )
    }]
)
print(response.content[0].text)

Vague vs Specific: Email Requests

Let's look at email writing — one of the most common AI tasks.

Vague: 'Write an email to my client.'
The model does not know the client, the topic, the relationship, the goal, or the tone.

Specific: 'Write a 3-paragraph email to a B2B SaaS client (TechFlow Inc) who missed their payment by 14 days. Tone: firm but professionally courteous. Goal: prompt payment without damaging the relationship. Include a specific call to action with a 5-day deadline.'

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

specific_prompt = (
    'Write a 3-paragraph professional email to a B2B SaaS client (TechFlow Inc) '
    'who has a payment 14 days overdue. '
    'Tone: firm but courteous — preserve the business relationship. '
    'Include: acknowledgment of potential oversight, the overdue amount placeholder [AMOUNT], '
    'a payment link placeholder [LINK], and a 5-day deadline. '
    'Subject line included.'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': specific_prompt}]
)
print(response.choices[0].message.content)

Vague vs Specific: Summarization

Even summarization — which seems simple — benefits enormously from specificity.

Vague: 'Summarize this article.'

Specific: 'Summarize this article in exactly 3 sentences. First sentence: main finding. Second sentence: methodology used. Third sentence: most significant implication for practitioners.'

The structure-specific version is immediately usable; the vague version requires reformatting.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

article = (
    'Researchers at MIT have developed a new neural network architecture that achieves '
    '94% accuracy on medical image diagnosis, outperforming human radiologists by 7%. '
    'The model was trained on 2.4 million anonymized X-ray images and uses a novel '
    'attention mechanism that highlights regions of interest for clinician review. '
    'The team expects FDA clearance by Q3 2025 for use as a diagnostic aid, not replacement.'
)

specific_prompt = (
    f'Summarize the following article in exactly 3 sentences:\n'
    f'Sentence 1: main finding.\n'
    f'Sentence 2: methodology.\n'
    f'Sentence 3: key implication for clinicians.\n\n'
    f'Article:\n{article}'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=200,
    messages=[{'role': 'user', 'content': specific_prompt}]
)
print(response.content[0].text)

Vague vs Specific: Brainstorming

Brainstorming prompts are where vagueness is most costly — you get a list of obvious, overlapping ideas.

Vague: 'Give me ideas for my app.'

Specific: 'Give me 10 unique monetization strategies for a B2C meditation app targeting 25-35 year-old urban professionals. Exclude subscription models (we already have one). Each idea in one sentence, ordered from most to least risky.'

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

specific_brainstorm = (
    'Generate 10 unique monetization strategies for a B2C meditation app '
    'targeting 25-35 year-old urban professionals. '
    'Exclude: subscription models (already implemented). '
    'Each strategy in one sentence. '
    'Order from most to least conventional. '
    'Label each with: CONVENTIONAL / EXPERIMENTAL / BOLD.'
)

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': specific_brainstorm}]
)
print(response.choices[0].message.content)

Using Examples in Prompts

One of the most powerful specificity techniques is to include examples of the output you want directly in your prompt (called few-shot prompting).

Instead of describing the format, show it. The model instantly understands structure, length, and tone from a real example — often more clearly than a written description.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

example_prompt = '''
Generate 3 product taglines in this style:

Example 1: Notion — 'The all-in-one workspace where better thinking happens.'
Example 2: Figma — 'Design together. Ship faster.'
Example 3: Linear — 'The issue tracker you'll actually enjoy using.'

Product: A CLI tool that automatically writes Git commit messages by analyzing your diff.
Taglines:
'''

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=200,
    messages=[{'role': 'user', 'content': example_prompt}]
)
print(response.content[0].text)

Specifying What NOT to Do

Negative constraints are just as powerful as positive ones. Telling the model what to avoid helps prevent common unwanted patterns:

  • 'Do not use bullet points'
  • 'Do not start with the word I'
  • 'Do not suggest solutions that require a credit card'
  • 'Do not use passive voice'

Pair positive instructions with negative constraints for maximum control.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[
        {
            'role': 'system',
            'content': (
                'You are a copywriter. Rules:\n'
                '- NEVER start a sentence with "Additionally" or "Furthermore"\n'
                '- NEVER use the phrase "In conclusion"\n'
                '- NEVER use passive voice\n'
                '- NEVER use bullet points or lists'
            )
        },
        {
            'role': 'user',
            'content': 'Write a 100-word about us section for a craft bakery called Morning Light.'
        }
    ]
)
print(response.choices[0].message.content)

Iterative Specificity

You do not have to write the perfect prompt on the first try. Iterative refinement is a valid strategy:

  1. Start with a moderately specific prompt
  2. Identify what is wrong or missing in the output
  3. Add constraints to address those gaps
  4. Repeat until the output meets your standard

Each iteration teaches you what constraints the model needs. Save your best prompts as templates for future use.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Iteration 1: first attempt
v1 = 'Write a LinkedIn post about my new job.'

# Iteration 2: add specifics based on what was missing
v2 = (
    'Write a LinkedIn post (max 150 words) announcing I just joined Stripe as a Senior Engineer. '
    'Tone: genuine excitement, not bragging. '
    'Include: what drew me to the role, one thing I plan to focus on. '
    'No cliches like "excited to announce" or "humbled to share". '
    'End with a genuine question for my network.'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{'role': 'user', 'content': v2}]
)
print(response.content[0].text)

Building a Specificity Checklist

Before sending any prompt, run through this mental checklist:

  • Have I specified the output format? (paragraph / list / JSON / table)
  • Have I specified the length? (word count / number of items)
  • Have I specified the audience? (who reads this)
  • Have I specified the tone? (formal / casual / technical)
  • Have I specified the goal? (what this output will be used for)
  • Have I included constraints? (what to avoid)
  • Could I add an example to show what I mean?
# Prompt template with all specificity dimensions filled
prompt_template = '''
Task: {task_description}
Format: {format}
Length: {length}
Audience: {audience}
Tone: {tone}
Goal: {goal}
Do NOT: {constraints}
Example of good output: {example}
'''

filled = prompt_template.format(
    task_description='Explain what an API is',
    format='3 short paragraphs, plain prose — no bullet points',
    length='150 words maximum',
    audience='Non-technical business stakeholders',
    tone='Friendly, analogy-based, jargon-free',
    goal='Prepare them for a meeting with the engineering team',
    constraints='Do not use the words "endpoint", "REST", or "HTTP"',
    example='An API is like a waiter in a restaurant — it takes your order...'
)
print(filled)

Knowledge Check

A marketing manager asks the AI: 'Write a social media post.' The AI returns a generic two-sentence post about the company. Which is the BEST rewrite to get a useful result?

Why Specificity Matters — Recap

Specificity is the foundation of effective prompting. Key takeaways:

  • Vague prompts produce statistically average, generic output
  • Specify format, length, audience, tone, and goal for every prompt
  • Use negative constraints to prevent unwanted patterns
  • Include examples of the output style you want
  • Use iterative refinement — no prompt needs to be perfect on the first try
  • Save winning prompts as templates for reuse

The more specific you are, the less time you spend rewriting the output.

Frequently asked questions

Is the “Why Specificity Matters” lesson free?

Yes — the full text of “Why Specificity Matters” 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 “Why Specificity Matters”?

How vague prompts lead to generic outputs — and how precision fixes it. 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 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Why Specificity Matters” 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

  1. Why Specificity Matters
  2. Removing Ambiguity from Prompts
  3. Adding Concrete Details
  4. Vague vs Specific Prompts Compared
← Back to AI Prompt Engineering