The Anatomy of a Good Prompt

The Problem

Your prompts are inconsistent. Sometimes brilliant results, sometimes garbage. You've read the guides, tried the techniques, but you can't reliably reproduce quality outputs.

The issue isn't randomness. It's structure. Good prompts share an anatomy. Bad prompts are missing pieces or have them in the wrong order.

Once you see the skeleton, you can build reliable prompts for anything.

The Core Insight

Every effective prompt has five components. Not all are required for every task, but knowing which to include—and which to omit—is the skill.

Order matters. Context before Task. Task before Format. Constraints throughout.

The Walkthrough

Types of context:

1. Domain context - "You are reviewing Python code for a fintech application"
2. Situational context - "The user is a beginner who just learned loops"
3. Reference context - "Given this function: [code]"
4. Historical context - "Previously, we decided to use PostgreSQL"

Context calibration:

Too little: "Write a function"
→ Model guesses language, purpose, style

Too much: "Write a Python 3.11 function using type hints following 
          PEP 8 style guide for a Django 4.2 application running on 
          AWS Lambda with 128MB memory..."
→ Overwhelms with irrelevant constraints

Right amount: "Write a Python function for a REST API. Use type hints."
→ Enough to guide, not enough to constrain unnecessarily

The context test: If removing a piece of context wouldn't change the output, you don't need it.

Effective task statements:

• Start with a verb: "Write," "Explain," "Analyze," "Debug," "Refactor"
• Be specific about scope: "the authentication flow" not "the code"
• State completion criteria: "until all tests pass" or "in under 50 lines"

Vague: "Help with this code"
→ Model doesn't know if you want review, explanation, fix, or rewrite

Specific: "Refactor this function to reduce cyclomatic complexity below 10"
→ Clear action, measurable outcome

Overly specific: "Refactor line 14 to use a ternary operator and line 
                 23 to use list comprehension and..."
→ Micromanagement that may produce worse solutions

The task test: Could someone verify the task was completed? If "help with code" - how do you know when you're done?

Output as JSON:
{
  "issues": [...],
  "suggestions": [...],
  "severity": "high|medium|low"
}

Output as markdown:
## Summary
[one paragraph]

## Detailed Findings
[bullet points]

Format reduces post-processing. If you need JSON, ask for JSON. Don't ask for text and parse it yourself.

The format test: Will you need to transform the output before using it? If yes, specify a better format.

Types of constraints:

1. Exclusions - "Don't use external libraries"
2. Limits - "Maximum 20 lines"
3. Prohibitions - "Never use eval()"
4. Style - "No passive voice"

Constraint placement: High-priority constraints go early:

# High priority - put first
IMPORTANT: Never log sensitive data.

# Medium priority - in context
...following the existing code style...

# Low priority - at end
Keep response under 500 words if possible.

The constraint test: Does removing this constraint risk output you can't use? If no, it's optional. If yes, it's essential.

When to use examples:

• Novel formats the model hasn't seen
• Specific style you want replicated
• Edge cases that need special handling
• Disambiguation of vague instructions

Input: def add(a, b): return a + b
Output: Pure function, no side effects, O(1) complexity

Input: def get_user(id): return db.query(...)
Output: Database dependency, potential SQL injection, O(n) for table scan

Input: [YOUR CODE HERE]
Output:

Example quality matters more than quantity. Two good examples beat five mediocre ones.

The examples test: Would a junior developer understand what to do from the examples alone? If not, add clarifying text.

Minimum Viable Prompts

Simple tasks (1-2 components)

Explain list comprehensions.
[Task only - context implicit from simplicity]

Given x = [1,2,3], write code to double each element.
[Reference context + Task]

Standard tasks (3-4 components)

You're reviewing Python code for security issues.
Analyze this function: [code]
List issues as bullet points with severity ratings.
[Context + Task + Format]

Complex tasks (all 5)

You are a senior engineer reviewing code for a payment system.
The codebase uses Django and PostgreSQL.

Analyze this function for security vulnerabilities: [code]

Format your response as:
- Severity (critical/high/medium/low)
- Issue description
- Recommended fix
- Example of fixed code

Focus only on security. Don't mention style or performance.

Example:
Input: cursor.execute(f"SELECT * FROM users WHERE id={id}")
Output:
- Severity: Critical
- Issue: SQL injection via string interpolation
- Fix: Use parameterized queries
- Example: cursor.execute("SELECT * FROM users WHERE id=%s", [id])

Now analyze: [actual code]

Prompt Surgery: Fixing Weak Prompts

Failure Patterns

Quick Reference

[CONTEXT - if needed]
You are [role]. You're working on [situation]. 
Given: [reference material]

[TASK - always]
[Action verb] [specific scope] [completion criteria].

[FORMAT - if needed]
Output as:
[structure specification]

[CONSTRAINTS - if needed]
- Must: [requirements]
- Must not: [prohibitions]
- Prefer: [soft preferences]

[EXAMPLES - if helpful]
Input: [example input]
Output: [example output]