<role>
You are a [specific role, e.g., senior data analyst specialising in SaaS metrics].
You communicate in [tone, e.g., clear, direct language suitable for a non-technical executive audience].
</role>

<context>
[Paste your background information, data, or reference material here.
This section should contain ONLY the information the model needs to work with — no instructions.]
</context>

<task>
[Write your specific instruction here. Use a strong action verb to start.
Be explicit about what "done" looks like.
Example: "Analyse the quarterly revenue data in <context> and identify the top 3 trends that explain the 12% decline in Q3."]
</task>

<format>
[Define the exact output structure you expect.
Example:
- Start with a one-sentence executive summary
- Follow with 3 numbered findings, each containing: the trend, the supporting data point, and a recommended action
- Close with a single paragraph summarising the risk if no action is taken
- Total length: 300-400 words]
</format>

<constraints>
[List what the model must NOT do.
Example:
- Do not speculate beyond the data provided in <context>
- Do not use jargon — explain any technical terms in plain English
- Do not exceed 400 words]
</constraints>

<role>
You are a customer success specialist who writes empathetic, solution-focused responses to frustrated users.
</role>

<task>
Write a response to the customer complaint in <input>. Match the tone, structure, and length demonstrated in the examples below.
</task>

<examples>

<example_1>
<input>Your software crashed and I lost 3 hours of work. This is unacceptable.</input>
<output>I completely understand your frustration — losing 3 hours of work is genuinely terrible, and I'm sorry this happened to you.

Here's what I'm doing right now to help:
1. I've flagged the crash report from your session to our engineering team for immediate investigation
2. I'm checking whether your work can be recovered from our auto-save logs (I'll have an update within 2 hours)
3. I've added a 30-day extension to your subscription as a small acknowledgement that this shouldn't have happened

You'll hear from me by end of day with the recovery update. If you need anything before then, reply here and I'll prioritise it.</output>
</example_1>

<example_2>
<input>I've been waiting 5 days for a response to my billing query. This is ridiculous.</input>
<output>You're absolutely right — 5 days is far too long, and I apologise for the wait.

I've just reviewed your billing query and here's where we stand:
1. The duplicate charge of £49.99 on 15th March was a processing error on our end
2. I've initiated the refund — it will appear in your account within 3-5 working days
3. I've also flagged your account to ensure this doesn't recur

If the refund hasn't appeared by next Friday, reply to this message and I'll escalate it directly to our finance team. No more waiting.</output>
</example_2>

</examples>

<input>
[Paste the actual customer complaint here]
</input>

<format>
Follow the exact structure shown in the examples:
- Open with empathy acknowledging the specific frustration
- "Here's what I'm doing" section with numbered concrete actions
- Close with a specific next step and timeline
- Total length: 100-150 words
</format>

<role>
You are a senior business strategist analysing competitive market data.
</role>

<context>
[Paste your data, report, or information here]
</context>

<task>
Analyse the data in <context> and recommend whether we should enter the [specific market/segment].

IMPORTANT: Before providing your recommendation, you MUST work through your reasoning step-by-step inside <thinking> tags. Your thinking process must explicitly address:

1. Market size and growth trajectory — what do the numbers actually show?
2. Competitive landscape — who are the incumbents and what are their weaknesses?
3. Our capabilities — based on the context, what advantages and gaps do we have?
4. Risk factors — what are the top 3 things that could go wrong?
5. Financial viability — does the opportunity justify the investment based on the data provided?

Only AFTER completing all 5 reasoning steps should you provide your final recommendation.
</task>

<format>
Structure your response as:

<thinking>
[Your complete step-by-step reasoning here — be thorough, this is where the real analysis happens]
</thinking>

**Recommendation:** [Go / No-Go / Conditional Go]

**Rationale:** [3-4 sentences summarising the key reasoning]

**Key conditions:** [If conditional, list the specific conditions that must be met]

**Primary risk:** [The single biggest risk and how to mitigate it]
</format>

<role>
You are an expert prompt engineer. Your speciality is designing structured prompts that produce consistent, high-quality outputs from large language models.
</role>

<task>
I need a prompt that will [describe your goal in plain language, e.g., "help me write weekly project status updates that my CTO will actually read"].

Design a complete, production-ready prompt for this task. Your prompt must include:

1. A clearly defined role for the AI
2. Explicit context placeholders showing what information the user needs to provide
3. A specific task instruction with measurable completion criteria
4. An output format specification with exact structure
5. At least one few-shot example demonstrating the ideal output
6. Constraints listing what the AI must avoid

After writing the prompt, critique it:
- Identify any ambiguous words that could be interpreted multiple ways
- Flag any missing context that would cause inconsistent outputs
- Suggest one improvement that would make the output more reliable

Then provide the final, improved version.
</task>

<role>
You are a context engineering consultant. Your job is to identify exactly what information is missing, ambiguous, or contradictory in the context you've been given — and explain how each gap affects your ability to complete the task accurately.
</role>

<context>
[Paste the full context you currently provide to your AI for this task]
</context>

<task>
I need you to [describe the task this context is meant to support, e.g., "write accurate product descriptions for our e-commerce store"].

Before attempting the task, perform a thorough context audit:

1. **MISSING INFORMATION:** List every piece of information you would need to complete this task reliably that is NOT present in <context>. For each item, explain specifically how its absence would degrade your output.

2. **AMBIGUOUS INFORMATION:** Identify any statements in <context> that could be interpreted multiple ways. For each, list the possible interpretations and explain which one you'd default to (and why that default might be wrong).

3. **CONTRADICTORY INFORMATION:** Flag any statements that conflict with each other. Explain how you'd resolve the contradiction and why that resolution might be incorrect.

4. **NOISE:** Identify any information in <context> that is irrelevant to the task and could distract from the core objective.

5. **CONTEXT SCORE:** Rate the context 1-10 for task readiness, with a one-sentence justification.

6. **PRIORITY FIXES:** List the top 3 context additions that would most improve output quality, ranked by impact.
</task>

<format>
Use the numbered structure above. Be specific and actionable — don't say "more product information needed," say "the material composition and care instructions for each product are missing, which means I'll either hallucinate these details or omit them."
</format>

<role>
You are a context engineering specialist who creates machine-readable context files for AI agents.
</role>

<task>
I'm going to describe my project/business/workflow. Based on what I tell you, generate a complete `AGENTS.md` file that any AI agent could consume to immediately understand:

- What this project is and what problem it solves
- The tech stack, tools, and conventions in use
- The coding/writing/communication standards we follow
- The boundaries and rules an AI must respect when working on this project
- Common mistakes an AI would make without this context

Here's my project description:
[Describe your project, business, or workflow in plain language — be thorough. Include your tools, your standards, your pet peeves, your audience, your common tasks.]
</task>

<format>
Generate the file using this structure:

# AGENTS.md


## Project Overview

[What this project is, who it serves, what success looks like]

## Tech Stack & Tools

[Languages, frameworks, platforms, integrations]

## Conventions & Standards

[Naming conventions, file structures, formatting rules, communication tone]

## Domain Knowledge

[Key terms, business logic, industry-specific rules the AI must understand]

## Boundaries & Constraints

[What the AI must NEVER do, compliance requirements, security boundaries]

## Common Tasks

[The 5-10 most frequent tasks an AI will be asked to perform, with brief guidance on each]

## Known Pitfalls

[Mistakes AI agents commonly make on this project and how to avoid them]
</format>

<role>
You are a senior AI infrastructure engineer specialising in Retrieval-Augmented Generation systems.
</role>

<context>
I have the following data source that I need to make searchable by an AI agent:

- **Data type:** [e.g., internal company wiki, legal contracts, customer support transcripts, technical documentation, codebase]
- **Total size:** [e.g., 500 documents, ~2 million words]
- **Structure:** [e.g., highly structured with headers/sections, semi-structured, unstructured prose, mixed media]
- **Primary use case:** [e.g., "Customer support agents need to find accurate answers to product questions in under 3 seconds"]
- **Accuracy requirements:** [e.g., "Zero tolerance for hallucination — answers must cite the exact source document"]
</context>

<task>
Design a complete RAG pipeline architecture for this use case. Specifically:

1. **Chunking Strategy:** Recommend the optimal chunking approach from: Fixed-size, Recursive Character, Semantic, Hierarchical, or Code-aware splitting. Justify your choice based on the data type and use case. Specify chunk sizes for both the Search stage (small chunks for matching) and the Retrieve stage (larger chunks for comprehension).

2. **Embedding Model:** Recommend a specific embedding model and explain why it suits this data type.

3. **Vector Database:** Recommend a vector store (Chroma, Pinecone, Weaviate, Qdrant, etc.) and justify the choice based on scale, cost, and use case requirements.

4. **Retrieval Strategy:** Should this use semantic search only, hybrid search (semantic + keyword), or a re-ranking pipeline? Explain the trade-offs.

5. **Evaluation Plan:** Define 3 specific metrics to measure whether this RAG pipeline is actually working (e.g., chunk attribution rate, answer faithfulness, retrieval precision).

6. **Failure Modes:** List the top 3 ways this pipeline could fail and how to detect each failure early.
</task>

<format>
Use numbered sections matching the task structure. For each recommendation, provide:
- The recommendation
- Why it's the best choice for THIS specific use case
- What would go wrong if you chose the most common alternative instead
</format>

<role>
You are an AI systems architect specialising in Model Context Protocol (MCP) server design.
</role>

<context>
I want to build an MCP server that gives AI agents access to:
[Describe your data sources and tools, e.g., "our PostgreSQL customer database, our internal Confluence wiki, and our Stripe billing API"]

The agents using this server will primarily need to:
[Describe the tasks, e.g., "answer customer questions about their accounts, look up billing history, and find relevant help articles"]

Security requirements:
[e.g., "Agents must never see raw credit card numbers. All database queries must be read-only. API calls to Stripe must be limited to lookup operations only — no mutations."]
</context>

<task>
Design the complete MCP server blueprint:

1. **Resources** (read-only data the agent can access):
   - List each resource with its schema, description, and access level
   - Specify what data is exposed and what is explicitly redacted

2. **Tools** (executable functions the agent can invoke):
   - List each tool with its name, input parameters, return type, and a one-sentence description
   - Specify rate limits and permission boundaries for each tool

3. **Prompts** (reusable instruction templates):
   - Design 2-3 server-side prompt templates for the most common agent tasks

4. **Transport recommendation:**
   - STDIO (local) vs. HTTP/SSE (remote) — recommend the right transport for this deployment and explain why

5. **Security boundaries:**
   - Define the explicit data redaction rules
   - Specify which operations are read-only vs. read-write
   - List the conditions under which the server should refuse a request
</task>

<role>
You are a [specific role] operating as part of [team/organisation].
</role>

<intent>
OBJECTIVE: [The business problem this task exists to solve]
Example: "Enable the product team to prioritise the Q3 roadmap by providing a data-backed analysis of feature requests ranked by revenue impact."

SUCCESS CRITERIA — this task is complete when:
- [ ] [Measurable outcome 1, e.g., "The top 10 feature requests are ranked by estimated revenue impact with supporting data"]
- [ ] [Measurable outcome 2, e.g., "Each recommendation includes implementation effort estimate (S/M/L) so the team can assess ROI"]
- [ ] [Measurable outcome 3, e.g., "The analysis is concise enough to be consumed in under 10 minutes"]

AUDIENCE: [Who will consume this output and what decision will they make with it]
Example: "Product VP and 3 senior PMs. They will use this to lock the Q3 roadmap in their Thursday planning session."
</intent>

<context>
[Your data and background information]
</context>

<constraints>
- [What must be avoided]
- [Hard boundaries]
- [Quality standards]
</constraints>

<format>
[Structure specification — but note: format serves the intent, not the other way round]
</format>

<role>
You are an intent engineering architect. You design structured, machine-readable intent schemas that govern autonomous AI agent behaviour.
</role>

<task>
I'm deploying an AI agent for the following purpose:

**Agent purpose:** [Describe what the agent will do, e.g., "Autonomously review and respond to customer support tickets for our SaaS platform"]

**Operating environment:** [Where it operates, e.g., "Integrated with Zendesk via API, accessing our knowledge base and customer database"]

**Autonomy level:** [How much independence it has, e.g., "Can resolve Tier 1 tickets independently. Must escalate Tier 2+ to human agents."]

Generate a complete 7-Component Intent Schema:

1. **OBJECTIVE (Unlock Question)**
   Write a singular mission statement (1-2 sentences) that defines the exact business problem this agent exists to solve. This must be specific enough that any ambiguous edge case can be resolved by asking "does this action serve the objective?"

2. **DESIRED OUTCOMES (Completion Criteria)**
   Define 5-7 explicit, measurable conditions that define success. Each must be binary — either met or not met. Include both positive criteria (what must happen) and negative criteria (what must not happen).

3. **HEALTH METRICS (Non-Regression Guardrails)**
   Define 4-6 KPIs the agent must monitor continuously. For each metric, specify:
   - The metric name
   - The acceptable range
   - The threshold that triggers an alert
   - The threshold that triggers automatic escalation

4. **STRATEGIC CONTEXT (Framework Loading)**
   Write 3-5 sentences explaining WHY this agent exists in the broader organisational context. What business strategy does it serve? What happens if it fails? This is the "tribal knowledge" the agent needs to make intelligent inferences.

5. **CONSTRAINTS (Quality Standards)**
   List 8-12 hard rules the agent must never violate. Categorise them as:
   - **Data constraints:** [What data it can/cannot access or share]
   - **Action constraints:** [What it can/cannot do]
   - **Communication constraints:** [Tone, language, disclosure rules]
   - **Compliance constraints:** [Legal, regulatory, or policy requirements]

6. **DECISION AUTONOMY (Delegation Protocol)**
   Create an explicit decision matrix:
   - **AUTONOMOUS (no approval needed):** [List specific decision types]
   - **NOTIFY (act, then inform human):** [List specific decision types]
   - **APPROVE (request human approval before acting):** [List specific decision types]
   - **FORBIDDEN (never attempt, always escalate):** [List specific decision types]

7. **STOP RULES (Kill Switches / Circuit Breakers)**
   Define 5-7 deterministic conditions where the agent must immediately halt:
   - [Condition][Action: halt / escalate / alert]
   Include at minimum:
   - Confidence threshold (e.g., "If confidence in any response drops below 70%, escalate")
   - Error cascade (e.g., "If 3 consecutive actions fail, halt and alert")
   - Boundary violation (e.g., "If any constraint from section 5 is at risk of being violated, halt immediately")
   - Time/cost limit (e.g., "If the agent has spent more than X minutes or $Y on a single task, escalate")
</task>

<format>
Output the schema as a structured YAML document that can be directly committed to a repository and consumed by an agent orchestration framework.
</format>

<task>
I'm building an AI agent that operates in a domain where the following objectives frequently conflict:

- [Objective A, e.g., "Response speed — resolve issues quickly"]
- [Objective B, e.g., "Customer satisfaction — ensure the customer feels heard and valued"]
- [Objective C, e.g., "Cost efficiency — minimise resource usage per interaction"]
- [Objective D, e.g., "Accuracy — ensure all information provided is correct"]

Design a trade-off hierarchy that explicitly defines:

1. **Priority ranking:** Order these objectives from highest to lowest priority. Explain the reasoning.

2. **Conflict resolution rules:** For each possible pair of conflicting objectives, write a specific rule. Example:
   - "When SPEED conflicts with ACCURACY: Always choose accuracy. A slow correct answer is acceptable; a fast wrong answer is not."
   - "When SATISFACTION conflicts with COST: Choose satisfaction when the customer's lifetime value exceeds £500. Choose cost efficiency for one-time or low-value interactions."

3. **Override conditions:** Define specific scenarios where the normal priority order flips. Example:
   - "During a system outage affecting more than 100 users, SPEED becomes the top priority regardless of normal hierarchy."

4. **Measurement:** For each objective, define how the agent should measure whether it's meeting the standard (specific metrics, not vague assessments).
</task>

<format>
Output as a structured decision matrix that an agent orchestration system can consume programmatically.
</format>

<role>
You are a systems architect specialising in AI governance and compliance infrastructure.
</role>

<task>
Design a traceable audit chain for an autonomous AI agent that:

**Agent description:** [What the agent does]
**Risk level:** [Low / Medium / High / Critical]
**Regulatory requirements:** [Any compliance frameworks, e.g., GDPR, SOC 2, FCA guidelines]

Your audit chain design must include:

1. **Event taxonomy:** Define every event type the agent can produce (decision made, tool invoked, context retrieved, escalation triggered, error encountered). For each event type, specify the exact fields that must be logged.

2. **Payload schema:** Design the JSON payload structure for audit log entries. Include:
   - Unique event ID
   - Timestamp (ISO 8601)
   - Agent identity (bound to cryptographic key)
   - Event type
   - Input data hash (not the raw data — for privacy)
   - Reasoning trace (which intent rules were evaluated)
   - Action taken
   - Outcome
   - Hash of previous log entry (for chain integrity)

3. **Storage architecture:** Recommend the storage approach:
   - Append-only database type (hash-chained SQLite, WORM store, etc.)
   - Retention policy
   - Access controls (who can read, who can't)

4. **Verification mechanism:** How to verify the chain hasn't been tampered with. Include the hashing algorithm recommendation and the verification procedure.

5. **Alert triggers:** Define 5 conditions that should generate automatic alerts to the human oversight team.
</task>