home / skills / fusengine / agents / prompt-creation

This skill helps you craft high-performance prompts following Anthropic conventions and 2025 best practices for clear task, tone, and rules.

npx playbooks add skill fusengine/agents --skill prompt-creation

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
2.7 KB
---
name: prompt-creation
description: Techniques and templates for creating optimal prompts following Anthropic conventions
allowed-tools: Read, Write
---

# Prompt Creation

Skill for creating high-performance prompts following 2025 best practices and Anthropic conventions.

## Documentation

- [techniques.md](docs/techniques.md) - Structuring techniques (CoT, Few-shot, etc.)
- [templates.md](docs/templates.md) - Reusable templates

## Anthropic Official Structure (9 Elements)

Each system prompt should cover these 9 aspects:

### 1. Task Context
```markdown
# Task Context
You are an expert [ROLE] specializing in [DOMAIN].
Your goal is to [PRIMARY_OBJECTIVE].
```

### 2. Tone Context
```markdown
# Tone
- Tone: [formal/casual/technical/friendly]
- Length: [concise/detailed/adaptive]
- Format: [prose/lists/tables/mixed]
```

### 3. Task Description + Rules
```markdown
# Task Description
Here are important rules:
- Always [MANDATORY_BEHAVIOR]
- Never [FORBIDDEN_BEHAVIOR]
- If [CONDITION] then [ACTION]

If unsure, say "I don't have enough information to answer."
```

### 4. Examples (Few-shot)
```markdown
# Examples

<example>
Input: [STANDARD_CASE_INPUT]
Output: [EXPECTED_OUTPUT]
</example>

<example>
Input: [EDGE_CASE_INPUT]
Output: [EXPECTED_OUTPUT]
</example>
```

### 5. Input Data
```markdown
# Input Data
<document>
[USER_PROVIDED_CONTENT]
</document>
```

### 6. Immediate Task
```markdown
# Immediate Task
Now, [SPECIFIC_ACTION] the above [document/code/data].
```

### 7. Precognition (Scratchpad)
```markdown
# Precognition
First, in <scratchpad> tags, analyze the key points.
Then provide your final answer in <answer> tags.
```

### 8. Output Formatting
```markdown
# Output Format

## Analysis
[Problem understanding]

## Solution
[Main response]

## Recommendations
[Additional suggestions]
```

### 9. Prefill (Assistant Turn)
```markdown
# Prefill
<scratchpad>
```

## Emphasis Techniques

In order of increasing effectiveness:

| Level | Syntax | Usage |
|-------|--------|-------|
| 1 | `Please do X` | Suggestion |
| 2 | `You should do X` | Recommendation |
| 3 | `Always do X` | Standard rule |
| 4 | `YOU MUST do X` | Strong rule |
| 5 | `IMPORTANT: Do X` | Critical rule |
| 6 | `CRITICAL - ZERO TOLERANCE: Do X` | Absolute rule |

## Creation Workflow

```
1. DEFINE the objective (1 sentence)
   ↓
2. IDENTIFY target audience
   ↓
3. LIST constraints
   ↓
4. CHOOSE techniques (CoT? Few-shot?)
   ↓
5. WRITE with 9-element structure
   ↓
6. ADD guardrails
   ↓
7. TEST mentally (edge cases)
   ↓
8. ITERATE if necessary
```

## Forbidden

- Never create prompts without clear objective
- Never write ambiguous instructions
- Never forget error cases
- Never ignore target model context

Overview

This skill teaches techniques and templates for creating high-performance prompts that follow Anthropic conventions. It packages a 9-element system structure, emphasis strategies, and a tested creation workflow to produce consistent, reliable prompts. The content focuses on clarity, guardrails, and repeatable templates for developer and product use.

How this skill works

The skill inspects a prompt objective, audience, and constraints, then applies the 9-element Anthropic structure to produce a complete system prompt. It provides recommended wording levels for rules, examples for few-shot learning, and output-format templates. A step-by-step workflow guides prompt design, testing, and iteration to surface edge cases and add guardrails.

When to use it

  • Designing system or assistant prompts for Anthropic-style agents
  • Creating few-shot examples and structured output formats
  • Onboarding new models or integrating prompts into code pipelines
  • Building guardrails and safety rules for agent behavior
  • Testing prompt robustness against edge cases

Best practices

  • Start with a single-sentence objective and identify the target audience before drafting
  • Always include explicit mandatory and forbidden behaviors; never leave error cases unspecified
  • Use the 9-element structure: context, tone, rules, examples, input, task, scratchpad, output format, and prefill
  • Prefer clear, graded instruction strength (e.g., Please → You should → Always → CRITICAL)
  • Iterate with mental testing and edge-case examples before deploying prompts

Example use cases

  • Generate a system prompt for a technical assistant that returns JSON with Analysis, Solution, and Recommendations
  • Create few-shot examples for clarifying ambiguous user intents in customer support flows
  • Draft a prompt that enforces strict privacy and data-handling rules for a medical domain agent
  • Build a template for code-review agents that include a scratchpad and final answer tags
  • Create adaptive tone prompts that switch between concise and detailed based on user preference

FAQ

How do I choose which of the 9 elements to emphasize?

Emphasize elements that affect correctness and safety first: Task Description + Rules, Examples, and Output Formatting. Tone and Prefill can be lighter unless user experience depends on them.

What strength of wording should I use for safety rules?

Use graded strength: start with direct recommendations for routine behaviors, escalate to MUST or CRITICAL for safety, legal, or privacy constraints to ensure zero tolerance is communicated.