Core Prompt Components

An effective prompt can be decomposed into four distinct elements:

1. Directive: Defines the exact operation the model should execute.
2. Payload: Supplies the specific content or data to be processed.
3. Context: Provides environmental constraints, rules, or background details.
4. Schema: Specifies the expected structure, format, or delimiters for the response.

While the directive is mandatory, the remaining elements are optional depending on the task. Their careful composition drastically reduces ambiguity and extraneous output.

Consider a classification task in which the model must validate a mathematical statement. The prompt is assembled as follows:

• Directive: Evaluate the following mathematical statement.
• Payload: Statement: 2 + 2 = 5
• Context: Answer "Correct" for true statements and "Incorrect" for false statements. Do not include conversational filler.
• Schema:

  ## Verdict
  {Correct or Incorrect}
  

Concatenating these sections with newline delimiters produces the final prompt:

Evaluate the following mathematical statement.
Statement: 2 + 2 = 5
Context: Answer "Correct" for true statements and "Incorrect" for false statements. Do not include conversational filler.
Output Schema:
## Verdict
{Correct or Incorrect}

Structured Output and Regular Expression Parsing

Vague constraints such as "reply with only Correct or Incorrect" are often insufficient; models may still prepend explanatory sentences. Enforcing the four-component structure yields deterministic, machine-readable output.

For example, the structured prompt above returns:

## Verdict
Incorrect

When an application requires multiple data points, the schema expands:

Evaluate the following mathematical statement.
Statement: 2 + 2 = 5
Context: Answer "Correct" for true statements and "Incorrect" for false statements.
Output Schema:
## Verdict
{Correct or Incorrect}

## Reason
{One-sentence explanation}

This produces:

## Verdict
Incorrect

## Reason
Integer addition dictates that two plus two equals four.

Because the model emits predictable delimiters, a regular expression parser can extract fields reliably. The following Python snippet illustrates the generation and extraction pipeline:

import re
import openai

prompt_body = (
    "Evaluate the following mathematical statement.\n"
    "Statement: 2 + 2 = 5\n"
    "Context: Answer 'Correct' for true statements and 'Incorrect' for false statements.\n"
    "Output Schema:\n"
    "## Verdict\n"
    "{Correct or Incorrect}\n\n"
    "## Reason\n"
    "{One-sentence explanation}"
)

completion = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt_body}]
)

generated_text = completion.choices[0].message.content

verdict_re = re.compile(r'## Verdict\s*\n(.*?)(?=\n\s*##|\Z)', re.DOTALL)
reason_re = re.compile(r'## Reason\s*\n(.*)', re.DOTALL)

verdict_hit = verdict_re.search(generated_text)
reason_hit = reason_re.search(generated_text)

status = verdict_hit.group(1).strip() if verdict_hit else None
justification = reason_hit.group(1).strip() if reason_hit else None

print(status)
print(justification)

Explicit structural markers—such as ## headers—act as parse anchors. By combining rigorous prompt schemas with lightweihgt regex extraction, developers can integrate LLM outputs directly into databases, business logic, and automated workflows without manual cleanup.