system-prompt-creator

Files (7)

• README.md
• README.vi.md
• README.zh.md
• SKILL.md
• model-specific.md · references/
• principles.md · references/
• templates.md · references/

SKILL.md (first lines)

# System Prompt Creator

Build effective system prompts for any LLM using a structured, research-backed process derived from the official prompting guides of Claude (Anthropic), GPT-5 (OpenAI), and Gemini (Google).

This skill guides you through interview, analysis, structuring, drafting, and optimization — producing system prompts that are clear, well-structured, and tailored to the target model.

## Workflow

Follow these 5 steps in order. Each step builds on the previous.

### Step 1: Interview — Gather Requirements

Before writing anything, collect these essentials from the user:

1. **Target model** — Which LLM? (Claude, GPT, Gemini, open-source, or model-agnostic)
2. **Use case** — What will the AI do? (chatbot, agent, content generator, data extractor, code assistant, etc.)
3. **Persona** — Who should the AI be? (role, expertise level, personality traits)
4. **Audience** — Who interacts with it? (developers, end users, internal team, customers)
5. **Input types** — What will users send? (free text, code, documents, images, structured data)
6. **Output format** — What should responses look like? (prose, JSON, markdown, code, tables)
7. **Tone & style** — Formal, casual, technical, friendly? Concise or detailed?
8. **Constraints** — What must it NOT do? (safety rules, topic limits, action restrictions)
9. **Tools & capabilities** — Does it have tool access? (APIs, file system, web search, code execution)
10. **Examples** — Can the user provide examples of good/bad responses?

If the user is vague on some points, suggest reasonable defaults and confirm before proceeding.

**Push for completeness:** After gathering basics, ask "What *else* might users ask about?" Many prompts fail not because they handle their core task poorly, but because they don't anticipate adjacent scenarios. A billing chatbot also gets account access questions, product questions, and complaints. A coding agent needs to handle not just building features but also debugging, refactoring, and project setup. Map the full territory before writing.

### Step 2: Analyze — Determine Complexity & Scope

Based on the interview, classify the prompt complexity:

| Complexity | Characteristics | Typical Length |
|-----------|----------------|---------------|
| **Simple** | Single task, no tools, fixed format | 50-200 words |
| **Moderate** | Multiple behaviors, some tools, varied outputs | 200-800 words |
| **Complex** | Agentic, multi-tool, long-running, safety-critical | 800-2000+ words |

Then determine which sections are needed:

- **Role/Persona** — Almost always needed
- **Context/Knowledge** — When domain expertise or background is required
- **Instructions/Rules** — Always needed
- **Domain Playbooks** — When the system handles multiple distinct operational scenarios (see below)
- **Output Format** — When response structure matters
- **Examples** — When accuracy and consistency matter (3-5 diverse examples)
- **Tool Usage** — When the model has access to tools or APIs
- **Safety/Guardrails** — When actions have real-world consequences
- **Agentic Behavior** — When the model operates autonomously

**Domain Playbooks:** For systems that handle multiple distinct workflows (a coding agent that builds, debugs, refactors, and reviews; a support bot that handles billing, accounts, and technical issues), include named playbooks — concise step-by-step patterns for each operational scenario. These give the model a reliable decision tree for common situations rather than forcing it to derive the approach from general instructions every time. Place playbooks inside the `<instructions>` section, organized by scenario name.

### Step 3: Structure — Apply the Layered Architecture

Organize the prompt using this universal architecture. Include only the sections relevant to the use case.

**XML structure** (preferred for complex prompts):

```xml
<role>
  Who the AI is, expertise, personality
</role>

<context>
  Domain knowledge, background information, constraints
</context>

<instructions>
  Core behavior rules, workflow steps, decision criteria
</instructions>

<output_format>
  Response structure, formatting rules, verbosity guidelines
</output_format>

<examples>
  3-5 diverse input/output pairs covering normal cases and edge cases
</examples>

<tools>
  Tool usage guidelines, when to use each tool, safety thresholds
</tools>

<guardrails>
  Safety boundaries, escalation rules, refusal criteria
</guardrails>
```

**Markdown structure** (suitable for simpler prompts):

```markdown
# Role
...

# Instructions
...

# Output Format
...
```

**Why structure matters:** When a prompt mixes instructions, context, examples, and inputs without clear boundaries, models may confuse which content serves which purpose. Structured tags eliminate this ambiguity and directly improve instruction adherence.

### Step 4: Draft — Apply the 12 Universal Principles

These principles represent the consensus from all 3 major LLM providers on what makes system prompts effective.

#### A. Structure Principles

**P1 — Layered Architecture.** Organize into distinct labeled sections (role, context, instructions, format, examples, guardrails). This directly affects how the model parses and prioritizes information.

**P2 — Consistent Tags.** Use XML tags or markdown headings consistently. Never mix conventions. Nest tags for hierarchical content (documents containing sub-documents).

**P3 — Content Ordering.** Place long reference material at the top. Place the task/query at the bottom. This alone can improve quality by up to 30% on complex multi-document tasks. Use anchoring phrases: "Based on the information above..."

#### B. Content Principles

**P4 — Explicit Intent + Reasoning.** Explain *why* a rule exists, not just *what* it is. Models generalize better from reasoning than from bare commands.

From tronghieu/agent-skills, MIT.

More from tronghieu/agent-skills