Using Delimiters, XML Tags, and Markdown to Structure Prompts

Prompts are not just text — they are structured documents the model parses on the fly. Delimiters, XML tags, and Markdown are how you signal structure clearly. Picking the right one for the right purpose noticeably improves attention, robustness, and parseability.

1. Introduction

When a prompt mixes instructions, user-supplied data, examples, and output specs into one long block of prose, the model is forced to guess which words belong to which section. Sometimes the guess is right and the answer is great. Sometimes the model treats your example as if it were the real task. Sometimes user input bleeds into instructions, opening a door for prompt injection. The cure for all of these is structure.

Modern models have been heavily trained on XML, Markdown, triple-backtick fences, and JSON. They use those structural cues exactly the way humans use headings and bullet points in a well-written brief — to figure out what each chunk of the document is for.

2. The Concept Explained

Three structuring tools cover roughly 95% of real prompts. Each has a sweet spot.

XML tags

Best for separating roles and data containers. They are visually obvious, easy to parse with a regex, and most models — Claude in particular — have been explicitly trained to treat them as containers. Use tags for high-stakes boundaries: untrusted data, examples, system constraints, and required output structure.

Markdown headings and lists

Best for instruction structure — the parts of the prompt you are writing for the model to read top-to-bottom. Headings make sections easy for the model to attend to; bullets make lists easier to follow than the same content as prose. Use Markdown to organise your own writing inside the prompt.

Triple backticks / code fences

Best for code blocks and verbatim content where you do not want the model to interpret the contents as Markdown. Models reliably treat backtick-fenced content as code or literal text, which prevents formatting from leaking into the output.

3. The Problem Without Structure

You are a code reviewer. Review the following code for
correctness, security, and style. The user is a junior
developer. Be encouraging but specific. Here is the code:
function login(u,p){if(u=="admin"&&p=="1234"){return true}
return false}. Tell me what's wrong with it. Also if the
user asks any unrelated questions, ignore them.

4. The Solution: Layered Structure

<role>
You are a code reviewer working with junior developers.
Tone: encouraging, but specific. No hand-waving.
</role>

<rules>
- Review only the code provided.
- Cover correctness, security, and style — in that order.
- If the user asks unrelated questions, politely refuse.
</rules>

<code language="javascript">
function login(u, p) {
  if (u == "admin" && p == "1234") {
    return true;
  }
  return false;
}
</code>

<output_format>
## Summary
One sentence verdict.

## Issues
- **Severity (High/Med/Low)** — issue description and fix.

## Refactor
A cleaned-up version of the function.
</output_format>

5. Step-by-Step Breakdown

1. Identify the sections of your prompt. Role, rules, examples, data, output spec, user question — each is a section.
2. Wrap data in XML tags. Anything the model should treat as input (not instructions) goes inside named tags like <document>, <email>, <user_query>. Tell the model in the system prompt that content inside these tags is data, not commands. This is also your front-line injection defense.
3. Use Markdown for instructions. Numbered lists for steps, bulleted lists for rules, headings for sections. The model parses these effortlessly.
4. Use triple-backtick fences for verbatim content. Code, JSON, log snippets, regex patterns — anything where you need character-level fidelity should go inside a fenced block.
5. Pick one style per kind of content. Don't mix <example> and ## Example for the same purpose within the same prompt. Consistency helps the model and your future self.
6. Describe the output structure too. Whether you want JSON, a table, or Markdown headings, show the model the structure either with a small example or an explicit template.

Tip: Different model families have slight preferences. Anthropic's Claude documentation explicitly recommends XML tags. OpenAI models work very well with Markdown sections and triple-backtick fences. In practice, all major models handle all three styles fine — pick what's clearest for the humans on your team and stay consistent.

6. Practice Exercises

7. Key Takeaways