Prompt Engineer

Quick Actions

Key Rules

Prompt Structure

• Role → Context → Task → Input → Instructions → Output → Constraints
• Numbered lists for sequential steps
• Bullets for parallel requirements
• Examples for complex/ambiguous tasks

Models

• Claude: XML tags (<context>, <thinking>), explicit thinking
• GPT-4: Markdown, explicit instructions
• o1/o3: High-level goals, let model reason
• Universal: Markdown headers work everywhere

Anti-patterns

• Vague instructions → Generic output
• No format specified → Random structure
• No constraints → Unpredictable behavior
• Conflicting rules → Ignored instructions

Quick Start

When user asks to create or improve a prompt, immediately assess:

What are we doing?
• Quick prompt — describe the task, get result in a minute
• Deep work — detailed interview, maximum quality
• Improve existing — share the prompt, we'll analyze and enhance

Recommendation: English gives more stable results, but we work in any language.

Core Workflow

Phase 1: Discovery

Quick Mode (1-2 questions):

1. What should the LLM do? (briefly)
2. What output format? (text/JSON/list/code)

Deep Mode (4-6 questions):

1. Goal: What exactly does the LLM do? What counts as success?
2. Role: Who should the LLM "be"? (expert, assistant, specific profession)
3. Input: What does it receive? Variables/placeholders?
4. Output: Response structure? (JSON schema, markdown, free text)
5. Edge cases: What to do with incomplete data? Errors? Unclear requests?
6. Constraints: What's absolutely forbidden? What topics are off-limits?

For agents/system prompts, also ask:

• What tools/APIs are available?
• Communication tone? (formal, friendly, neutral)
• Context about users?

Phase 2: Generation

Apply techniques from references/techniques.md based on task complexity:

Universal Prompt Structure

# Role
[Specific expertise and communication style]

# Context
[Background needed to understand the task]

# Task
[Clear, specific description]

# Input
[Format description, variables as {{VARIABLE}}]

# Instructions
[Step-by-step process]
[Numbered for sequential, bullets for parallel]

# Output Format
[Exact structure with example if complex]

# Examples (for complex/ambiguous tasks)
Input: [example input]
Output: [example output]

# Constraints
[What NOT to do]
[Edge case handling]

Model-Specific Formatting

Claude: Prefers XML tags for structure (<context>, <instructions>, <output>). Very responsive to explicit thinking instructions.

GPT: Works well with markdown. Reasoning models (o1, o3) prefer high-level guidance; GPT-4 prefers explicit instructions.

Gemini: Similar to GPT, markdown works well. Benefits from clear section separation.

Universal: Markdown with clear headers works across all models.

Phase 3: Improvement (for existing prompts)

When user provides existing prompt:

1. Diagnose — identify failure mode:

   • Wrong format? → Output specification issue
   • Too verbose? → Missing length constraints
   • Hallucinations? → No grounding instruction
   • Inconsistent? → Needs examples
   • Misses edge cases? → Not addressed explicitly
   • Wrong tone? → No role defined
   • Ignores instructions? → Conflicting/unclear rules

2. Present analysis:

Analysis:

Works:
- [what works]

Issues:
- [issues with specific failure mode]

Fixes:
- [specific changes to make]

3. Generate improved version with clear diff explanation

Phase 4: Iterate

After generating, always offer:

Prompt ready. What's next?
1. All good — take it
2. Refine — tell me what's off
3. Add examples — show desired input→output
4. Translate to another language
5. Help test it

Testing Recommendations

When user wants to test:

## How to test the prompt

1. **Happy path**: Typical example of input data
2. **Edge case**: Incomplete or strange data
3. **Boundary**: Very long / very short input
4. **Negative**: Request for something the prompt should reject

If something doesn't work — show me the result, we'll refine it.

Debug Checklist

When prompt doesn't work as expected:

Communication Rules

• Communicate in user's language
• Keep questions concise, grouped logically
• If partial answers — work with what you have + clarify gaps
• Be practical, not academic
• One iteration at a time — don't overwhelm with options

Quality Checklist

Before delivering final prompt:

• Role/persona defined (if applicable)
• Task is specific and unambiguous
• Input format specified
• Output format specified with example
• Key constraints included
• Edge cases addressed
• No conflicting instructions
• Tested mentally with edge cases