### Step 1: Be Specific, Not Vague The number one cause of bad AI output is vague instructions. Compare these two prompts: **Bad:** ``` Write about marketing. ``` **Good:** ``` Write a 500-word blog post explaining three email marketing strategies for B2B SaaS companies with under 1,000 subscribers. Include one real-world example for each strategy. Use a professional but conversational tone. ``` The good prompt specifies: length, topic, audience, quantity, evidence requirements, and tone. The model has no room to drift. **Rule of thumb:** If a human intern would ask clarifying questions after reading your prompt, the prompt is too vague. ### Step 2: Use Structured Formatting LLMs respond well to structured input. Use headings, numbered lists, and labeled sections to organize your prompt. ``` ROLE: Senior technical writer CONTEXT: - Product: Cloud-based project management tool - Audience: Non-technical small business owners - Existing docs: None TASK: Create a "Getting Started" guide with these sections: 1. Account creation (3 steps max) 2. Creating your first project 3. Inviting team members FORMAT: - Use H2 for section headers - Include a tip callout after each section - Keep sentences under 20 words CONSTRAINTS: - Do not mention API access or developer features - Do not reference competitor products ``` ### Step 3: Provide Examples (Few-Shot Prompting) Few-shot prompting means giving the model examples of the input-output pattern you want. This is one of the most powerful techniques available. ``` Classify the following customer messages by intent. Example 1: Input: "I can't log in to my account" Output: {"intent": "authentication", "urgency": "high", "sentiment": "frustrated"} Example 2: Input: "Do you have a dark mode option?" Output: {"intent": "feature_inquiry", "urgency": "low", "sentiment": "neutral"} Example 3: Input: "Your product saved me 3 hours this week!" Output: {"intent": "positive_feedback", "urgency": "none", "sentiment": "positive"} Now classify this message: Input: "The export button doesn't work on Firefox" Output: ``` The model learns the exact JSON structure, the field names, and the classification taxonomy from your examples. No lengthy explanation needed. ### Step 4: Chain-of-Thought Reasoning For complex tasks that require reasoning, tell the model to think step by step. This dramatically improves accuracy on math, logic, analysis, and multi-step problems. ``` A store sells notebooks for $4 each. A customer buys 3 notebooks and pays with a $20 bill. The store has no coins, only $1 and $5 bills. What is the correct change, and what bills should the cashier give? Think through this step by step before answering. ``` **Why it works:** Without chain-of-thought, the model jumps to an answer and sometimes gets it wrong. With it, the model "shows its work" and self-corrects along the way. ### Step 5: Assign a Role with Depth A shallow role ("You are a helpful assistant") adds nothing. A deep role with specific expertise, constraints, and behavioral rules transforms the output. ``` You are a database performance consultant with 15 years of experience in PostgreSQL optimization. You specialize in query tuning for high-traffic SaaS applications (10,000+ queries per second). When reviewing queries, you: - Always check for missing indexes first - Prefer covering indexes over table scans - Flag N+1 query patterns immediately - Recommend EXPLAIN ANALYZE output when you need more data - Never suggest denormalization without quantifying the trade-off The user will paste SQL queries. Analyze each one for performance issues. ```

{
  "model": "gpt-4o",
  "messages": [
    {"role": "system", "content": "You are a concise code reviewer. Reply only with the issue and fix. No explanations."},
    {"role": "user", "content": "Review this: def get_user(id): return db.query(f'SELECT * FROM users WHERE id = {id}')"}
  ]
}

{
  "model": "claude-sonnet-4-20250514",
  "system": "You are a concise code reviewer. Reply only with the issue and fix. No explanations.",
  "messages": [
    {"role": "user", "content": "Review this: def get_user(id): return db.query(f'SELECT * FROM users WHERE id = {id}')"}
  ]
}

{
  "model": "gemini-2.0-flash",
  "system_instruction": "You are a concise code reviewer. Reply only with the issue and fix.",
  "contents": [
    {"role": "user", "parts": [{"text": "Review this function..."}]}
  ]
}

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

You are a concise code reviewer. Reply only with the issue and fix.<|eot_id|>

<|start_header_id|>user<|end_header_id|>

Review this function...<|eot_id|>

<|start_header_id|>assistant<|end_header_id|>

Prompt 1 (Research): "Search for the top 5 competitors in the
AI writing assistant market. For each, list: name, pricing,
key features, and target audience."

Prompt 2 (Analysis): "Given this competitor data: [output from Prompt 1].
Identify the three biggest gaps in the market that no competitor
is addressing well."

Prompt 3 (Strategy): "Given these market gaps: [output from Prompt 2].
Write a positioning strategy for a new AI writing tool targeting
[specific audience]. Include messaging pillars and differentiation."

Answer the following question three different ways, using different
reasoning approaches each time. Then compare your three answers
and select the one you are most confident in. Explain why.

Question: Should a 50-person startup adopt microservices or
a modular monolith?

Write a product description for wireless headphones.

Constraints:
1. Exactly 3 paragraphs
2. First paragraph: the problem (max 2 sentences)
3. Second paragraph: the solution with 3 specific features
4. Third paragraph: social proof + CTA
5. Reading level: 8th grade (Flesch-Kincaid)
6. No superlatives (no "best", "amazing", "incredible")
7. Include one specific number (battery life, weight, or price)

I want to write a prompt that generates SQL queries from natural
language questions. Here is my current prompt:

[paste your prompt]

Analyze this prompt for weaknesses. Then rewrite it to be more
robust, handling edge cases like ambiguous table names, aggregate
queries, and JOINs across 3+ tables.

Fill in the sections marked [FILL] based on the codebase analysis:

## Architecture Overview
[FILL: 2-3 sentence summary of the system architecture]

## Tech Stack
| Layer | Technology | Version |
|-------|-----------|---------|
| Frontend | [FILL] | [FILL] |
| Backend | [FILL] | [FILL] |
| Database | [FILL] | [FILL] |

## Key Design Decisions
1. [FILL: Decision about data storage] — Rationale: [FILL]
2. [FILL: Decision about auth] — Rationale: [FILL]
3. [FILL: Decision about deployment] — Rationale: [FILL]

ROLE:
[Who is the AI in this context? What expertise does it have?]

CONTEXT:
[What background does the model need? What has happened before?]

TASK:
[What exactly should the model do? Be specific.]

FORMAT:
[How should the output be structured? Give an example if possible.]

CONSTRAINTS:
[What should the model NOT do? What are the boundaries?]

EXAMPLES (optional):
[Input/output pairs showing the pattern you want]