Prompt Engineering Mastery

❌ Bad prompt:    "Summarise this."
✅ Good prompt:   "Summarise the following customer support ticket in 2 sentences.
                   Focus on the issue and resolution. Tone: professional.
                   Output only the summary — no preamble."

System message  → sets the model's persona, rules, and constraints
                  (persists for the whole conversation)

User message    → the actual request from the user

Assistant message → previous model responses (for multi-turn conversations)

var messages = new List<ChatMessage>
{
    // System: what the model IS
    ChatMessage.CreateSystemMessage("""
        You are a senior .NET developer reviewing pull requests.
        Be specific, concise, and focus on correctness over style.
        Always include a code example when suggesting a change.
        Never praise — only flag issues or confirm correctness.
        """),

    // User: what the user WANTS
    ChatMessage.CreateUserMessage($"""
        Review this C# method:

        ```csharp
        {code}

**System prompts are your most powerful lever.** Spend more time on the system prompt than the user message — it defines how the model behaves for every request.

---

## Level 1: Zero-Shot Prompting

Ask directly — no examples needed. Works for simple, well-defined tasks:

Output: `Positive`

Tips for zero-shot:
- Be explicit about the output format
- Specify length: "in one sentence", "in under 50 words", "as a JSON object"
- State what NOT to include: "no preamble", "no explanation", "output only the code"

---

## Level 2: Few-Shot Prompting

Give 2–5 examples of input → output pairs. The model learns the pattern:

Output: `Critical`

Few-shot is powerful because you're teaching the *pattern* rather than explaining the rules. It works especially well for:
- Classification and labelling
- Format transformation (markdown → JSON, etc.)
- Tone matching

---

## Level 3: Chain-of-Thought (CoT)

For reasoning tasks, tell the model to think step by step before answering. This dramatically improves accuracy on logic, maths, and multi-step problems.

You can also use **"Let's think about this carefully"** or structure it explicitly:

For code generation, CoT looks like this:

---

## Level 4: Structured Output (JSON Mode)

For any application code, you want predictable, parseable output — not free text.

```csharp
// Force JSON output
var options = new ChatCompletionOptions
{
    ResponseFormat = ChatResponseFormat.CreateJsonObjectFormat(),
    Temperature    = 0.1f,
};

var messages = new List
{
    ChatMessage.CreateSystemMessage("""
        You are an API that extracts structured data.
        Always respond with valid JSON only. No markdown, no explanation.
        """),
    ChatMessage.CreateUserMessage($"""
        Extract the following fields from this invoice text:
        - vendor_name (string)
        - invoice_date (ISO 8601 date)
        - total_amount (number)
        - line_items (array of {{ description, quantity, unit_price }})

        Invoice text:
        {invoiceText}
        """),
};

var response = await chatClient.CompleteChatAsync(messages, options, ct);
var json     = response.Value.Content[0].Text;
var invoice  = JsonSerializer.Deserialize(json);

// Strict structured output — model MUST match your schema
var options = new ChatCompletionOptions();
options.ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
    "invoice",
    BinaryData.FromString("""
    {
      "type": "object",
      "properties": {
        "vendor_name":    { "type": "string" },
        "invoice_date":   { "type": "string", "format": "date" },
        "total_amount":   { "type": "number" },
        "line_items": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "description": { "type": "string" },
              "quantity":    { "type": "integer" },
              "unit_price":  { "type": "number" }
            },
            "required": ["description", "quantity", "unit_price"]
          }
        }
      },
      "required": ["vendor_name", "invoice_date", "total_amount", "line_items"],
      "additionalProperties": false
    }
    """),
    strictSchemaEnabled: true
);

[IDENTITY]
You are a code review assistant for Learnixo. You help developers improve 
their .NET and C# code. You are direct, technically precise, and never waste words.

[RULES]
- Only review C# / .NET code. Politely decline other requests.
- Flag bugs before style issues.
- Always show a corrected code snippet for every issue you raise.
- Never produce output longer than 500 words.
- If the code is correct, say so in one sentence and stop.

[OUTPUT FORMAT]
Respond in this exact structure:
## Issues Found
(list each issue with a before/after code example, or write "None" if no issues)

## Summary
(one sentence)

[TONE]
Senior developer peer review. No encouragement, no filler.

[SYSTEM]
You are a customer support agent for Learnixo. 
Answer questions using ONLY the context provided below.
If the answer is not in the context, say "I don't have that information."
Never make up information. Keep answers to 3 sentences max.

[CONTEXT]
{retrieved_documents}

[USER QUESTION]
{user_question}

You are a research assistant. You have access to these tools:
- search(query: string) → returns web search results
- calculate(expression: string) → evaluates a mathematical expression

For complex questions, use this format:
Thought: [your reasoning about what to do next]
Action: [tool name and input]
Observation: [tool result]
... (repeat Thought/Action/Observation as needed)
Final Answer: [your conclusion]

Question: What is 15% of the GDP of the UK in 2024?

Thought: I need to find the UK GDP in 2024 first.
Action: search("UK GDP 2024 total")
Observation: UK GDP in 2024 was approximately £2.5 trillion ($3.1 trillion)
Thought: Now I can calculate 15% of £2.5 trillion.
Action: calculate("2500000000000 * 0.15")
Observation: 375000000000
Final Answer: 15% of the UK's GDP in 2024 is approximately £375 billion.

You are an expert C# developer. Write production-quality code only.
Include XML doc comments on public members.
Use async/await throughout. Throw descriptive exceptions.
No placeholder comments like "// TODO" or "// implement this".

Task: {task}

Summarise the following article for a technical audience.

Rules:
- Maximum 5 bullet points
- Each bullet: one sentence
- Focus on actionable insights, not background
- Use plain language — no jargon unless necessary

Article:
{article}

Extract all dates mentioned in the following text.
Return a JSON array of objects: [{ "date": "YYYY-MM-DD", "context": "what the date refers to" }]
If no dates found, return [].
Output JSON only — no markdown, no explanation.

Text: {text}

Classify the following support message into exactly one category:
billing | technical | feature-request | abuse | other

Rules:
- Output only the category name — nothing else
- If unsure between two, pick the more severe one
- "abuse" takes priority over all others

Message: {message}

❌ Vague instructions
"Make it better" — better how? shorter? more formal? more accurate?

✅ "Rewrite this paragraph to be 30% shorter without losing any key information."

---

❌ Contradictory rules
"Be concise but comprehensive."

✅ "Cover these 3 points only: [list]. One sentence per point."

---

❌ No output format
"Extract the important info."

✅ "Extract: name, email, company. Return JSON: { name, email, company }.
    If a field is missing, use null."

---

❌ Relying on the model to "just know"
"Write code in our style."

✅ Provide 2–3 examples of your code style in the system prompt.

---

❌ No length constraint
"Write a blog post about X."

✅ "Write a 400-word blog post about X. No introduction paragraph — start with the main point."

// Run your prompt against a set of test cases
var testCases = new[]
{
    new { Input = "Production server down", Expected = "Critical" },
    new { Input = "Dashboard is slow",      Expected = "Medium"   },
    new { Input = "Add dark mode",          Expected = "Low"      },
};

var passed = 0;
foreach (var test in testCases)
{
    var result = await classifier.ClassifyAsync(test.Input);
    if (result == test.Expected) passed++;
    else Console.WriteLine($"FAIL: '{test.Input}' → '{result}' (expected '{test.Expected}')");
}

Console.WriteLine($"{passed}/{testCases.Length} tests passed.");