Imported from organvm-iv-taxis/a-i--skills (skills/tools/prompt-engineering-patterns/SKILL.md). Install upstream with npx skills add organvm-iv-taxis/a-i--skills --skill prompt-engineering-patterns. Copyright stays with the author (MIT).

Prompt Engineering Patterns

Design prompts that produce reliable, structured, high-quality outputs from language models.

Prompt Architecture

System Prompt Structure

┌─ Identity & Role ─────────────────┐
│ Who the model is, what it does     │
├─ Context & Constraints ───────────┤
│ Domain knowledge, guardrails       │
├─ Output Format ───────────────────┤
│ Structure, length, style           │
├─ Examples (Few-Shot) ─────────────┤
│ Input/output pairs                 │
├─ Instructions ────────────────────┤
│ Step-by-step task guidance         │
└────────────────────────────────────┘

Priority Layering

When instructions conflict, models follow this precedence:

1. System prompt — Highest structural authority
2. Most recent user message — Immediate task context
3. Earlier conversation — Background context
4. Training data — Default behaviors

Core Patterns

Structured Output

<system>
Analyze the given code and return findings in this exact format:

<analysis>
  <summary>One-sentence overall assessment</summary>
  <findings>
    <finding severity="high|medium|low">
      <location>file:line</location>
      <issue>Description</issue>
      <fix>Recommended fix</fix>
    </finding>
  </findings>
  <score>1-10</score>
</analysis>
</system>

Chain of Thought

Before answering, think through the problem step by step:

1. Identify the core question
2. List relevant constraints
3. Consider 2-3 approaches
4. Evaluate tradeoffs
5. Recommend the best approach with reasoning

Show your reasoning in <thinking> tags, then give your final answer.

Few-Shot Examples

Classify the following commit messages by type.

Examples:
- "Add user authentication with JWT" → feat
- "Fix null pointer in dashboard render" → fix
- "Update README with API documentation" → docs
- "Refactor database connection pooling" → refactor

Now classify:
- "Implement rate limiting for API endpoints" →

Role Prompting

You are a senior security engineer reviewing code for a financial services application.
Your priorities are:
1. Authentication and authorization flaws
2. Data exposure risks
3. Input validation gaps
4. Dependency vulnerabilities

Review with the paranoia appropriate for systems handling financial data.

Advanced Patterns

Constraint Prompting

Generate a Python function with these constraints:
- No external dependencies (stdlib only)
- Must handle the empty input case
- Must include type hints
- Maximum 20 lines
- Must include a docstring

Decomposition

Break complex tasks into sequential sub-prompts:

Step 1: Analyze the current code structure
Step 2: Identify the specific change needed
Step 3: Write the minimal diff
Step 4: Verify the change doesn't break existing behavior

Self-Verification

After generating your response:
1. Re-read the original question
2. Check that every requirement is addressed
3. Verify any code compiles/runs mentally
4. Flag any assumptions you made

Negative Prompting

Specify what NOT to do:

Important:
- Do NOT add error handling beyond what was requested
- Do NOT refactor surrounding code
- Do NOT add comments explaining obvious operations
- Do NOT change the function signature

Claude-Specific Patterns

XML Tags for Structure

Claude responds well to XML-tagged sections:

<context>
  Repository: a-i--skills
  Organ: IV (Orchestration)
  Current branch: feature/governance-aware-skill-taxonomy
</context>

<task>
  Create a new skill following the existing frontmatter format.
</task>

<constraints>
  - Match the YAML frontmatter schema exactly
  - Name must match directory name
  - Include governance metadata fields
</constraints>

Extended Thinking

For complex reasoning tasks, allocate thinking budget:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,
    },
    messages=[{"role": "user", "content": prompt}],
)

Tool Use

Define tools for structured interaction:

tools = [{
    "name": "create_skill",
    "description": "Create a new skill file",
    "input_schema": {
        "type": "object",
        "required": ["name", "category", "description"],
        "properties": {
            "name": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
            "category": {"type": "string"},
            "description": {"type": "string", "maxLength": 600},
        },
    },
}]

Multi-Turn Conversation Design

Context Window Management

Conversation budget allocation:
- System prompt: ~2K tokens (fixed)
- Conversation history: ~50K tokens (growing)
- Current task context: ~10K tokens (variable)
- Response space: ~4K tokens (reserved)

Conversation Summarization

When context grows large, summarize earlier turns:

<conversation_summary>
In previous messages, we:
1. Identified the bug in auth middleware (missing token refresh)
2. Agreed on fix approach (add refresh check before expiry)
3. Implemented the fix in src/auth/middleware.ts
</conversation_summary>

Now continuing with testing...

Prompt Testing

Evaluation Criteria

A/B Testing Prompts

async def evaluate_prompts(prompts: list[str], test_cases: list[dict]) -> dict:
    results = {}
    for i, prompt in enumerate(prompts):
        scores = []
        for case in test_cases:
            output = await generate(prompt, case["input"])
            score = evaluate(output, case["expected"])
            scores.append(score)
        results[f"prompt_{i}"] = sum(scores) / len(scores)
    return results

Anti-Patterns

• Vague instructions — "Do something good" vs. "Return a JSON object with exactly 3 fields"
• Conflicting constraints — "Be concise" + "Explain thoroughly"
• Prompt injection vulnerability — Always separate system instructions from user input
• No output format spec — Always specify expected format for machine-consumed output
• Over-prompting — Adding unnecessary instructions that dilute important ones
• Ignoring model capabilities — Using chain-of-thought when a simple instruction suffices