Advanced Prompt Engineering

Today, We'll learn how to make AI applications more reliable, consistent, and easier to maintain. 

Part 1: Prompt chaining

1. What is prompt chaining?

Prompt chaining means dividing one complicated task into multiple smaller AI tasks, where the output of one step becomes the input to the next.

Imagine asking an AI to review a large C# service, identify performance problems, recommend improvements, and generate revised code—all in one prompt.

That may work, but the model could miss issues, mix analysis with recommendations, or produce too much output.

Instead, divide the task into stages.

2. Example: Reviewing a .NET API

Suppose you want AI to review an API that retrieves inventory and demand.

Notice that each step has a clear responsibility. In a real implementation, your application passes the previous step's output into the next step.

3. Why is chaining useful?

Single large prompt Prompt chain

One complex task Several focused tasks

Harder to isolate mistakes Easier to inspect each stage

Output can become inconsistent Each stage can have its own output format

Difficult to retry just one part Failed stages can often be retried independently

Important: Chaining does not automatically make AI more accurate. An error in an earlier step can propagate through the entire chain. Validate important intermediate results, and use deterministic code for calculations and business rules wherever possible.

Part 2: Structured outputs

4. Why does structured output matter?

Imagine your .NET API asks an LLM to classify an incoming support ticket.

A normal text response might be:

This looks like a high-priority performance issue affecting inventory retrieval.

That makes sense to a person, but your application must somehow extract the priority and category.

Instead, ask for a structured response.

Now your application has clearly named fields it can deserialize and validate.

5. Map the JSON to a C# model

Your application can deserialize the response into this type using System.Text.Json: 

In production, also handle malformed JSON, missing fields, unexpected enum values, and model/API errors. Deserialization alone does not guarantee that the data is valid.

6. Prompt for predictable output

This prompt defines the expected shape and allowed values.

There is one important distinction:

• Prompt-based JSON: You request JSON through instructions. The model may still return invalid or unexpected content.

• Schema-constrained structured output: When supported by the model/API, you supply a schema that constrains the response to the required structure.

For production applications, prefer schema-constrained output where available, then validate the result in C#. Neither approach replaces authorization, business-rule validation, or safe handling of external input.

Part 3: Prompt evaluation

7. How do you know whether a prompt is good?

A prompt that works for one example may fail on another. Professional AI development requires testing prompts against a collection of representative inputs.

Suppose your application uses AI to classify material-related support requests.

You could create this test dataset:

Test input Expected category

“Inventory screen loads very slowly.” Performance

“User can access another asset's records.” Security

“Material quantity is incorrect.” Data

“How do I change my display name?” Other

Run every test case against your prompt and compare the actual result with the expected result.

A simple prompt evaluation workflow

1. Prepare test cases. Include normal inputs, edge cases, ambiguous requests, and unexpected inputs.

2. Run the same tests. Use the same model settings and record the outputs.

3. Compare results. Check category accuracy, valid output format, and whether facts were invented.

4. Improve the prompt. Fix specific failure patterns rather than making arbitrary changes.

5. Run regression tests. Verify that the new prompt fixes old failures without breaking previously successful cases.

For example, if the model repeatedly classifies incorrect material quantities as performance problems, clarify the distinction between slow retrieval and incorrect data in your instructions and examples.

You can measure basic classification accuracy:

Accuracy = Correct predictions / Total predictions

If 90 out of 100 classifications are correct, accuracy is 90%. But accuracy alone may be misleading when categories are imbalanced or some errors are much more serious than others. For security classifications, track missed security issues separately.

8. What should you record during testing?

For each run, record:

• Prompt version

• Model and relevant settings

• Input and expected output

• Actual output

• Pass/fail result and reason

• Latency and token usage, where available

This makes prompt changes measurable and helps you investigate regressions.

Part 4: Building reliable AI workflows

9. The production mindset

In a real application, don't treat the LLM as an ordinary method that always returns a correct answer.

Design the workflow like this:

Four practical rules:

1. Treat AI output as untrusted input. Validate it before using it in a database update or other operation.

2. Keep business rules in code. Use C# for calculations, authorization, and mandatory validation—not a prompt alone.

3. Handle failures explicitly. Apply appropriate timeouts, limited retries, and error handling.

4. Protect sensitive information. Send only the data needed, enforce access controls, and avoid logging secrets or unnecessary personal data.

For example, an LLM can recommend that an inventory record needs review. It should not independently override asset-level permissions or execute an unrestricted database update simply because its response says to do so.

Lesson 8 — Quick revision

• Prompt chaining: Break a complex task into smaller AI steps.

• Structured outputs: Return predictable JSON or schema-constrained data for application use.

• Prompt evaluation: Test prompts using representative cases and measurable results.

• Reliability: Validate outputs, handle failures, protect data, and keep business rules in code.