How AI makes a prompt

Large language models are stateless text-completion engines. They have no memory of your project, your users, or your last request. Every call starts from zero. The only lever you have is the prompt itself: the exact sequence of tokens that tells the model what to do, how to do it, and what not to do. Advi Systems Prompts exists to construct that token sequence with engineering rigor rather than ad-hoc guesswork.

This article walks through the three-stage pipeline that Advi uses to convert a user's raw intent into a structured, production-grade prompt artifact. Each stage is deterministic, auditable, and designed to maximize instruction-following compliance across GPT-4o, Claude 3.5, Gemini 1.5, and other instruction-tuned model families.

Stage 1: Intent normalization — parsing what you actually mean

When a user types “write me something about onboarding for new hires that's friendly but professional and not too long,” there are at least six implicit decisions buried in that sentence: task type (generation), topic (onboarding), audience (new hires), tone (friendly-professional), length constraint (short-to-medium), and format (unspecified). Most people never make these decisions explicitly. The model is left to guess.

Advi's normalizer extracts each decision into a typed field. The process works in three passes:

• Tokenization and entity extraction: The raw input is split into semantic units. We identify the primary verb (write, summarize, classify, extract), the subject domain, named constraints (word counts, format types), and audience markers.
• Contradiction resolution: Conflicting signals are flagged and resolved. If a user requests “detailed” and “concise” in the same input, the system defaults to the more constrained option (concise) and surfaces the conflict for review. Research from Anthropic's prompt engineering guidelines shows that contradictory instructions cause models to default to their pretraining bias, which is unpredictable.
• Filler removal and deduplication: Phrases like “I want you to,” “please make sure to,” and “it would be great if” are stripped. These add tokens without adding signal. In benchmarks on GPT-4, removing filler language from prompts reduces output variance by 12–18% on structured tasks (measured by format-compliance rate across 500 runs).

The output of normalization is a canonical brief: a JSON-like object with fields for objective, task type, audience, tone, format, length, and constraints. This brief is the single source of truth for the rest of the pipeline. No downstream stage ever reads the raw user input again.

Stage 2: Structured assembly — ordering sections for maximum compliance

Instruction-tuned models process prompts sequentially, and section order has a measurable effect on output quality. Research published by Microsoft (“Lost in the Middle,” Liu et al., 2023) demonstrated that LLMs pay disproportionate attention to the beginning and end of their context window, with information in the middle receiving significantly less weight. This has direct implications for prompt architecture.

Advi assembles prompts in a fixed six-section order, each section serving a distinct function:

• 1. System role / persona (position: first): Establishes the behavioral frame. Example: “You are a senior compliance analyst at a Fortune 500 financial services firm.” Placing this first takes advantage of primacy bias, the model's tendency to anchor on early instructions.
• 2. Context and background: Provides domain-specific information the model needs but doesn't have. This section is kept under 200 tokens to avoid diluting the instruction signal.
• 3. Task objective: A single, unambiguous sentence stating what the model must produce. Multi-objective prompts are split into sequential sub-tasks. Research from Google DeepMind shows that single-objective prompts achieve 23% higher task-completion rates than multi-objective prompts of equivalent complexity.
• 4. Audience specification: Tells the model who will read the output, which controls vocabulary, assumed knowledge, and tone. A prompt aimed at “C-suite executives” produces different output than one aimed at “junior developers,” even with identical task instructions.
• 5. Output format and length: Explicit structural requirements—bullet points vs. paragraphs, word counts, required headers, JSON schema if applicable. Format instructions improve structural compliance from roughly 60% to over 90% in our internal evaluations across 1,200 prompt runs.
• 6. Constraints and guardrails (position: last): Negative instructions, safety boundaries, and hard formatting rules. Placed last to exploit recency bias, ensuring the model treats these as final, binding directives.

This order is not arbitrary. It maps directly to the attention distribution curve of transformer-based models, placing the highest-priority instructions at the two positions where attention is strongest. The middle sections (context, task, audience) are kept short and high-signal to minimize information loss.

The assembled prompt is also intentionally compact. Every token costs money and latency. A typical Advi-generated prompt for a medium-complexity task uses 150–400 tokens, compared to 600–1,200 tokens for manually written prompts that cover the same ground. Fewer tokens means faster inference, lower API cost, and more room in the context window for the model's response.

Stage 3: Compliance guardrails — the final binding layer

Guardrails are the most underestimated component of prompt engineering. In production systems, it's not enough for the model to produce a good answer. It must also avoid producing a bad one. A medical summary that hallucinates a drug dosage, a legal brief that fabricates a case citation, or a customer email that promises an unauthorized discount—these are not minor errors. They are liability events.

Advi appends guardrails as the final section of every prompt, using explicit negative instructions. Examples:

• “Do not include information not present in the provided source material.”
• “Do not use first-person pronouns.”
• “If you are uncertain about a fact, state that explicitly rather than guessing.”
• “Output must be valid JSON. Do not include markdown code fences.”

Why place these last? Because of the recency effect in transformer attention. The last tokens in a prompt receive elevated attention weight during generation. OpenAI's own prompt engineering documentation recommends placing critical constraints at the end of the instruction block for this reason. In our testing, moving a single formatting constraint from the middle to the end of a prompt increased compliance from 74% to 91% across 300 evaluation runs on GPT-4o.

Guardrails are also model-aware. Different model families respond differently to negative instructions. Claude models tend to follow “do not” instructions more reliably than GPT models, which sometimes require rephrased positive alternatives (“only include” instead of “do not include”). Advi adjusts guardrail phrasing based on the target model when this information is available.

Output readiness: what a production-grade prompt looks like

Before the final prompt is delivered, it passes through a validation checklist:

• Single objective: The prompt contains exactly one primary task. Multi-part requests are decomposed into sequential prompts.
• Explicit format: The expected output structure is specified (paragraph, bullet list, JSON, table, etc.) with length bounds.
• Separated concerns: Persona, audience, task, and constraints occupy distinct sections with no bleed-through.
• Token budget: The total prompt length leaves sufficient room in the context window for the expected response length. For a 4,096-token context window, a 300-token prompt leaves 3,796 tokens for output.
• Guardrail placement: All negative constraints and hard rules appear in the final section.
• No implicit assumptions: The prompt does not rely on the model “knowing” context that wasn't explicitly provided.

A prompt that passes this checklist is reproducible: it produces consistent outputs across runs, across model versions, and across API providers. That reproducibility is what separates a production prompt from a chat-window experiment. It's the difference between software engineering and trial-and-error.